a Code for the Combination of Indirect and Direct Constraints on High Energy Physics Models Logo
HiggsThObservables.cpp
Go to the documentation of this file.
1/*
2 * Copyright (C) 2019 HEPfit Collaboration
3 *
4 *
5 * For the licensing terms see doc/COPYING.
6 */
7
9#include "NPbase.h"
10
11muggH::muggH(const StandardModel& SM_i, const double sqrt_s_i)
12: ThObservable(SM_i), sqrt_s(sqrt_s_i)
13{
14 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
15 throw std::runtime_error("muggH called with a class whose parent is not NPbase");
16}
17
19{
20 return myNPbase->muggH(sqrt_s);
21}
22
23muVBF::muVBF(const StandardModel& SM_i, const double sqrt_s_i)
24: ThObservable(SM_i), sqrt_s(sqrt_s_i)
25{
26 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
27 throw std::runtime_error("muVBF called with a class whose parent is not NPbase");
28
29}
30
32{
33 return myNPbase->muVBF(sqrt_s);
34}
35
36muVBFgamma::muVBFgamma(const StandardModel& SM_i, const double sqrt_s_i)
37: ThObservable(SM_i), sqrt_s(sqrt_s_i)
38{
39 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
40 throw std::runtime_error("muVBFgamma called with a class whose parent is not NPbase");
41
42}
43
45{
46 return myNPbase->muVBFgamma(sqrt_s);
47}
48
49mueeWBF::mueeWBF(const StandardModel& SM_i, const double sqrt_s_i)
50: ThObservable(SM_i), sqrt_s(sqrt_s_i)
51{
52 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
53 throw std::runtime_error("mueeWBF called with a class whose parent is not NPbase");
54
55}
56
58{
59 return myNPbase->mueeWBF(sqrt_s);
60}
61
62mueeWBFPol::mueeWBFPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
63: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
64{
65 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
66 throw std::runtime_error("mueeWBFPol called with a class whose parent is not NPbase");
67}
68
70{
72}
73
74mueeHvv::mueeHvv(const StandardModel& SM_i, const double sqrt_s_i)
75: ThObservable(SM_i), sqrt_s(sqrt_s_i)
76{
77 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
78 throw std::runtime_error("mueeHvv called with a class whose parent is not NPbase");
79}
80
82{
83 return myNPbase->mueeHvv(sqrt_s);
84}
85
86mueeHvvPol::mueeHvvPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
87: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
88{
89 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
90 throw std::runtime_error("mueeHvvPol called with a class whose parent is not NPbase");
91}
92
94{
96}
97
98mueeZBF::mueeZBF(const StandardModel& SM_i, const double sqrt_s_i)
99: ThObservable(SM_i), sqrt_s(sqrt_s_i)
100{
101 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
102 throw std::runtime_error("mueeZBF called with a class whose parent is not NPbase");
103
104}
105
107{
108 return myNPbase->mueeZBF(sqrt_s);
109}
110
111mueeZBFPol::mueeZBFPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
112: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
113{
114 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
115 throw std::runtime_error("mueeZBFPol called with a class whose parent is not NPbase");
116}
117
119{
121}
122
123muepWBF::muepWBF(const StandardModel& SM_i, const double sqrt_s_i)
124: ThObservable(SM_i), sqrt_s(sqrt_s_i)
125{
126 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
127 throw std::runtime_error("muepWBF called with a class whose parent is not NPbase");
128
129}
130
132{
133 return myNPbase->muepWBF(sqrt_s);
134}
135
136muWH::muWH(const StandardModel& SM_i, const double sqrt_s_i)
137: ThObservable(SM_i), sqrt_s(sqrt_s_i)
138{
139 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
140 throw std::runtime_error("muWH called with a class whose parent is not NPbase");
141}
142
144{
145 return myNPbase->muWH(sqrt_s);
146}
147
148muWHpT250::muWHpT250(const StandardModel& SM_i, const double sqrt_s_i)
149: ThObservable(SM_i), sqrt_s(sqrt_s_i)
150{
151 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
152 throw std::runtime_error("muWHpT250 called with a class whose parent is not NPbase");
153}
154
156{
157 return myNPbase->muWHpT250(sqrt_s);
158}
159
160muepZBF::muepZBF(const StandardModel& SM_i, const double sqrt_s_i)
161: ThObservable(SM_i), sqrt_s(sqrt_s_i)
162{
163 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
164 throw std::runtime_error("muepZBF called with a class whose parent is not NPbase");
165
166}
167
169{
170 return myNPbase->muepZBF(sqrt_s);
171}
172
173muZH::muZH(const StandardModel& SM_i, const double sqrt_s_i)
174: ThObservable(SM_i), sqrt_s(sqrt_s_i)
175{
176 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
177 throw std::runtime_error("muZH called with a class whose parent is not NPbase");
178}
179
181{
182 return myNPbase->muZH(sqrt_s);
183}
184
185muZHpT250::muZHpT250(const StandardModel& SM_i, const double sqrt_s_i)
186: ThObservable(SM_i), sqrt_s(sqrt_s_i)
187{
188 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
189 throw std::runtime_error("muZHpT250 called with a class whose parent is not NPbase");
190}
191
193{
194 return myNPbase->muZHpT250(sqrt_s);
195}
196
197
198mueeZHGen::mueeZHGen(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
199: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
200{
201 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
202 throw std::runtime_error("mueeZHGen called with a class whose parent is not NPbase");
203}
204
206{
208}
209
210
211mueeZH::mueeZH(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
212: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
213{
214 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
215 throw std::runtime_error("mueeZH called with a class whose parent is not NPbase");
216}
217
219{
221}
222
223mueeZllH::mueeZllH(const StandardModel& SM_i, const double sqrt_s_i)
224: ThObservable(SM_i), sqrt_s(sqrt_s_i)
225{
226 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
227 throw std::runtime_error("mueeZllH called with a class whose parent is not NPbase");
228}
229
231{
232 return myNPbase->mueeZllH(sqrt_s);
233}
234
235mueeZllHPol::mueeZllHPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
236: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
237{
238 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
239 throw std::runtime_error("mueeZllHPol called with a class whose parent is not NPbase");
240}
241
243{
245}
246
247mueeZqqH::mueeZqqH(const StandardModel& SM_i, const double sqrt_s_i)
248: ThObservable(SM_i), sqrt_s(sqrt_s_i)
249{
250 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
251 throw std::runtime_error("mueeZqqH called with a class whose parent is not NPbase");
252}
253
255{
256 return myNPbase->mueeZqqH(sqrt_s);
257}
258
259mueeZqqHPol::mueeZqqHPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
260: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
261{
262 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
263 throw std::runtime_error("mueeZqqHPol called with a class whose parent is not NPbase");
264}
265
267{
269}
270
271
272aPsk::aPsk(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
273: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
274{
275 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
276 throw std::runtime_error("aPsk called with a class whose parent is not NPbase");
277}
278
280{
282}
283
284
285bPsk::bPsk(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
286: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
287{
288 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
289 throw std::runtime_error("bPsk called with a class whose parent is not NPbase");
290}
291
293{
295}
296
297
298muVH::muVH(const StandardModel& SM_i, const double sqrt_s_i)
299: ThObservable(SM_i), sqrt_s(sqrt_s_i)
300{
301 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
302 throw std::runtime_error("muVH called with a class whose parent is not NPbase");
303}
304
306{
307 return myNPbase->muVH(sqrt_s);
308}
309
310muVHpT250::muVHpT250(const StandardModel& SM_i, const double sqrt_s_i)
311: ThObservable(SM_i), sqrt_s(sqrt_s_i)
312{
313 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
314 throw std::runtime_error("muVHpT250 called with a class whose parent is not NPbase");
315}
316
318{
319 return myNPbase->muVHpT250(sqrt_s);
320}
321
322muVBFpVH::muVBFpVH(const StandardModel& SM_i, const double sqrt_s_i)
323: ThObservable(SM_i), sqrt_s(sqrt_s_i)
324{
325 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
326 throw std::runtime_error("muVBFpVH called with a class whose parent is not NPbase");
327}
328
330{
331 return myNPbase->muVBFpVH(sqrt_s);
332}
333
334muttH::muttH(const StandardModel& SM_i, const double sqrt_s_i)
335: ThObservable(SM_i), sqrt_s(sqrt_s_i)
336{
337 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
338 throw std::runtime_error("muttH called with a class whose parent is not NPbase");
339}
340
342{
343 return myNPbase->muttH(sqrt_s);
344}
345
346mutHq::mutHq(const StandardModel& SM_i, const double sqrt_s_i)
347: ThObservable(SM_i), sqrt_s(sqrt_s_i)
348{
349 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
350 throw std::runtime_error("mutHq called with a class whose parent is not NPbase");
351}
352
354{
355 return myNPbase->mutHq(sqrt_s);
356}
357
358muggHpttH::muggHpttH(const StandardModel& SM_i, const double sqrt_s_i)
359: ThObservable(SM_i), sqrt_s(sqrt_s_i)
360{
361 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
362 throw std::runtime_error("muggHpttH called with a class whose parent is not NPbase");
363}
364
366{
367 return myNPbase->muggHpttH(sqrt_s);
368}
369
370mueettH::mueettH(const StandardModel& SM_i, const double sqrt_s_i)
371: ThObservable(SM_i), sqrt_s(sqrt_s_i)
372{
373 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
374 throw std::runtime_error("mueettH called with a class whose parent is not NPbase");
375
376}
377
379{
380 return myNPbase->mueettH(sqrt_s);
381}
382
383mueettHPol::mueettHPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
384: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
385{
386 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
387 throw std::runtime_error("mueettHPol called with a class whose parent is not NPbase");
388}
389
391{
393}
394
395mummH::mummH(const StandardModel& SM_i, const double sqrt_s_i)
396: ThObservable(SM_i), sqrt_s(sqrt_s_i)
397{
398 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
399 throw std::runtime_error("mummH called with a class whose parent is not NPbase");
400}
401
403{
404 return myNPbase->mummH(sqrt_s);
405}
406
407mummHNWA::mummHNWA(const StandardModel& SM_i, const double sqrt_s_i)
408: ThObservable(SM_i), sqrt_s(sqrt_s_i)
409{
410 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
411 throw std::runtime_error("mummHNWA called with a class whose parent is not NPbase");
412}
413
415{
416 return myNPbase->mummHNWA(sqrt_s);
417}
418
419// -----------------------------------------------------------------------------
420// Decay widths
421// -----------------------------------------------------------------------------
422
424: ThObservable(SM_i)
425{
426 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
427 throw std::runtime_error("GammaHtoggRatio called with a class whose parent is not NPbase");
428}
429
431{
432 return myNPbase->GammaHggRatio();
433}
434
436: ThObservable(SM_i)
437{
438 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
439 throw std::runtime_error("GammaHtoWWRatio called with a class whose parent is not NPbase");
440}
441
443{
444 return myNPbase->GammaHWWRatio();
445}
446
448: ThObservable(SM_i)
449{
450 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
451 throw std::runtime_error("GammaHtoZZRatio called with a class whose parent is not NPbase");
452}
453
455{
456 return myNPbase->GammaHZZRatio();
457}
458
460{
461 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
462 throw std::runtime_error("GammaHtoZgaRatio called with a class whose parent is not NPbase");
463}
464
466{
467 return myNPbase->GammaHZgaRatio();
468}
469
471{
472 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
473 throw std::runtime_error("GammaHtogagaRatio called with a class whose parent is not NPbase");
474}
475
477{
478 return myNPbase->GammaHgagaRatio();
479}
480
482{
483 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
484 throw std::runtime_error("GammaHtomumuRatio called with a class whose parent is not NPbase");
485}
486
488{
489 return myNPbase->GammaHmumuRatio();
490}
491
493{
494 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
495 throw std::runtime_error("GammaHtotautauRatio called with a class whose parent is not NPbase");
496}
497
499{
500 return myNPbase->GammaHtautauRatio();
501}
502
504{
505 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
506 throw std::runtime_error("GammaHtossRatio called with a class whose parent is not NPbase");
507}
508
510{
511 return myNPbase->GammaHssRatio();
512}
513
515{
516 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
517 throw std::runtime_error("GammaHtoccRatio called with a class whose parent is not NPbase");
518}
519
521{
522 return myNPbase->GammaHccRatio();
523}
524
526{
527 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
528 throw std::runtime_error("GammaHtobbRatio called with a class whose parent is not NPbase");
529}
530
532{
533 return myNPbase->GammaHbbRatio();
534}
535
537: ThObservable(SM_i)
538{
539 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
540 throw std::runtime_error("GammaHRatio called with a class whose parent is not NPbase");
541}
542
544{
546}
547
548// -----------------------------------------------------------------------------
549// Branching Ratios
550// -----------------------------------------------------------------------------
551
553{
554 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
555 throw std::runtime_error("BrHtoinvRatio called with a class whose parent is not NPbase");
556}
557
559{
560 return myNPbase->BrHtoinvRatio();
561}
562
564: ThObservable(SM_i)
565{
566 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
567 throw std::runtime_error("BrHinvisible called with a class whose parent is not NPbase");
568}
569
571{
572 return myNPbase->Br_H_inv();
573}
574
576: ThObservable(SM_i)
577{
578 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
579 throw std::runtime_error("BrHinvisibleNP called with a class whose parent is not NPbase");
580}
581
583{
584 return myNPbase->Br_H_inv_NP();
585}
586
588: ThObservable(SM_i)
589{
590 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
591 throw std::runtime_error("BrHexotic called with a class whose parent is not NPbase");
592}
593
595{
596 return myNPbase->Br_H_exo();
597}
598
600: ThObservable(SM_i)
601{
602 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
603 throw std::runtime_error("BrHtovisRatio called with a class whose parent is not NPbase");
604}
605
607{
608 return myNPbase->BrHvisRatio();
609}
610
612: ThObservable(SM_i)
613{
614 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
615 throw std::runtime_error("BrHtoggRatio called with a class whose parent is not NPbase");
616}
617
619{
620 return myNPbase->BrHggRatio();
621}
622
624: ThObservable(SM_i)
625{
626 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
627 throw std::runtime_error("BrHtoWWRatio called with a class whose parent is not NPbase");
628}
629
631{
632 return myNPbase->BrHWWRatio();
633}
634
636: ThObservable(SM_i)
637{
638 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
639 throw std::runtime_error("BrHtoZZRatio called with a class whose parent is not NPbase");
640}
641
643{
644 return myNPbase->BrHZZRatio();
645}
646
648: ThObservable(SM_i)
649{
650 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
651 throw std::runtime_error("BrHtoVVRatio called with a class whose parent is not NPbase");
652}
653
655{
656 return myNPbase->BrHVVRatio();
657}
658
660{
661 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
662 throw std::runtime_error("BrHtoZgaRatio called with a class whose parent is not NPbase");
663}
664
666{
667 return myNPbase->BrHZgaRatio();
668}
669
671{
672 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
673 throw std::runtime_error("BrHtoZgallRatio called with a class whose parent is not NPbase");
674}
675
677{
678 return myNPbase->BrHZgallRatio();
679}
680
682{
683 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
684 throw std::runtime_error("BrHtoZgaeeRatio called with a class whose parent is not NPbase");
685}
686
688{
689 return myNPbase->BrHZgaeeRatio();
690}
691
693{
694 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
695 throw std::runtime_error("BrHtoZgamumuRatio called with a class whose parent is not NPbase");
696}
697
699{
700 return myNPbase->BrHZgamumuRatio();
701}
702
704{
705 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
706 throw std::runtime_error("BrHtogagaRatio called with a class whose parent is not NPbase");
707}
708
710{
711 return myNPbase->BrHgagaRatio();
712}
713
715{
716 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
717 throw std::runtime_error("BrHtomumuRatio called with a class whose parent is not NPbase");
718}
719
721{
722 return myNPbase->BrHmumuRatio();
723}
724
726{
727 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
728 throw std::runtime_error("BrHtotautauRatio called with a class whose parent is not NPbase");
729}
730
732{
733 return myNPbase->BrHtautauRatio();
734}
735
737{
738 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
739 throw std::runtime_error("BrHtoccRatio called with a class whose parent is not NPbase");
740}
741
743{
744 return myNPbase->BrHccRatio();
745}
746
748{
749 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
750 throw std::runtime_error("BrHtobbRatio called with a class whose parent is not NPbase");
751}
752
754{
755 return myNPbase->BrHbbRatio();
756}
757
758// -----------------------------------------------------------------------------
759// More 4 fermion decays
760// -----------------------------------------------------------------------------
761
762
764: ThObservable(SM_i)
765{
766 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
767 throw std::runtime_error("BrHto2l2vRatio called with a class whose parent is not NPbase");
768}
769
771{
772 return myNPbase->BrH2l2vRatio();
773}
774
775
777: ThObservable(SM_i)
778{
779 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
780 throw std::runtime_error("BrHtoevmuvRatio called with a class whose parent is not NPbase");
781}
782
784{
785 return myNPbase->BrHevmuvRatio();
786}
787
788
790: ThObservable(SM_i)
791{
792 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
793 throw std::runtime_error("BrHto2e2vRatio called with a class whose parent is not NPbase");
794}
795
797{
798 // SM decay widths (from MG simulations)
799 double wH2e2vSM=0.93291e-06, wH2evSM=0.10152e-04;
800
801 // Sum
802 double wH2e2vTSM=wH2e2vSM+wH2evSM;
803
804 return ( (wH2e2vSM*(myNPbase->BrH2e2vRatio()) + wH2evSM*(myNPbase->BrH2evRatio())) / wH2e2vTSM );
805}
806
807
809: ThObservable(SM_i)
810{
811 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
812 throw std::runtime_error("BrHto2mu2vRatio called with a class whose parent is not NPbase");
813}
814
816{
817 // SM decay widths (from MG simulations)
818 double wH2mu2vSM=0.93288e-06, wH2muvSM=0.10163e-04;
819
820 // Sum
821 double wH2mu2vTSM=wH2mu2vSM+wH2muvSM;
822
823 return ( (wH2mu2vSM*(myNPbase->BrH2mu2vRatio()) + wH2muvSM*(myNPbase->BrH2muvRatio())) / wH2mu2vTSM );
824}
825
826
828: ThObservable(SM_i)
829{
830 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
831 throw std::runtime_error("BrHto4lRatio called with a class whose parent is not NPbase");
832}
833
835{
836 return myNPbase->BrH4lRatio();
837}
838
839
841: ThObservable(SM_i)
842{
843 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
844 throw std::runtime_error("BrHto4eRatio called with a class whose parent is not NPbase");
845}
846
848{
849 return myNPbase->BrH4eRatio();
850}
851
852
854: ThObservable(SM_i)
855{
856 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
857 throw std::runtime_error("BrHto4muRatio called with a class whose parent is not NPbase");
858}
859
861{
862 return myNPbase->BrH4muRatio();
863}
864
865
867: ThObservable(SM_i)
868{
869 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
870 throw std::runtime_error("BrHto2e2muRatio called with a class whose parent is not NPbase");
871}
872
874{
875 return myNPbase->BrH2e2muRatio();
876}
877
878
879
881: ThObservable(SM_i)
882{
883 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
884 throw std::runtime_error("BrHtolljjRatio called with a class whose parent is not NPbase");
885}
886
888{
889 return myNPbase->BrHlljjRatio();
890}
891
892
894: ThObservable(SM_i)
895{
896 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
897 throw std::runtime_error("BrHtolvjjRatio called with a class whose parent is not NPbase");
898}
899
901{
902 return myNPbase->BrHlvjjRatio();
903}
904
905
907: ThObservable(SM_i)
908{
909 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
910 throw std::runtime_error("BrHtolv_lvorjjRatio called with a class whose parent is not NPbase");
911}
912
914{
915 return myNPbase->BrHlv_lvorjjRatio();
916}
917
918
920: ThObservable(SM_i)
921{
922 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
923 throw std::runtime_error("BrHtoll_vvorjjRatio called with a class whose parent is not NPbase");
924}
925
927{
928 return myNPbase->BrHll_vvorjjRatio();
929}
930
931// -----------------------------------------------------------------------------
932// Ratios of BR (ratios with SM)
933// -----------------------------------------------------------------------------
934
936{
937 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
938 throw std::runtime_error("BrHtogaga_over_mumu_Ratio called with a class whose parent is not NPbase");
939}
940
942{
943 if ((this->getModel()).isModelLinearized()) {
944 return (1.0 + (myNPbase->BrHgagaRatio()) - (myNPbase->BrHmumuRatio()));
945 } else {
946 return (myNPbase->BrHgagaRatio()) / (myNPbase->BrHmumuRatio());
947 }
948}
949
951{
952 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
953 throw std::runtime_error("BrHtoZga_over_mumu_Ratio called with a class whose parent is not NPbase");
954}
955
957{
958 if ((this->getModel()).isModelLinearized()) {
959 return (1.0 + (myNPbase->BrHZgaRatio()) - (myNPbase->BrHmumuRatio()));
960 } else {
961 return (myNPbase->BrHZgaRatio()) / (myNPbase->BrHmumuRatio());
962 }
963}
964
966{
967 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
968 throw std::runtime_error("BrHtoZmumuga_over_mumu_Ratio called with a class whose parent is not NPbase");
969}
970
972{
973 if ((this->getModel()).isModelLinearized()) {
974 return (1.0 + (myNPbase->BrHZgamumuRatio()) - (myNPbase->BrHmumuRatio()));
975 } else {
977 }
978}
979
981{
982 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
983 throw std::runtime_error("BrHtogaga_over_4l_Ratio called with a class whose parent is not NPbase");
984}
985
987{
988 if ((this->getModel()).isModelLinearized()) {
989 return (1.0 + (myNPbase->BrHgagaRatio()) - (myNPbase->BrH4lRatio()));
990 } else {
991 return (myNPbase->BrHgagaRatio()) / (myNPbase->BrH4lRatio());
992 }
993}
994
996{
997 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
998 throw std::runtime_error("BrHtobb_over_4l_Ratio called with a class whose parent is not NPbase");
999}
1000
1002{
1003 if ((this->getModel()).isModelLinearized()) {
1004 return (1.0 + (myNPbase->BrHbbRatio()) - (myNPbase->BrH4lRatio()));
1005 } else {
1006 return (myNPbase->BrHbbRatio()) / (myNPbase->BrH4lRatio());
1007 }
1008}
1009
1010
1012{
1013 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1014 throw std::runtime_error("BrHto2l2v_over_4l_Ratio called with a class whose parent is not NPbase");
1015}
1016
1018{
1019 if ((this->getModel()).isModelLinearized()) {
1020 return (1.0 + (myNPbase->BrH2l2vRatio()) - (myNPbase->BrH4lRatio()));
1021 } else {
1022 return (myNPbase->BrH2l2vRatio()) / (myNPbase->BrH4lRatio());
1023 }
1024}
1025
1026
1028{
1029 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1030 throw std::runtime_error("BrHtotautau_over_4l_Ratio called with a class whose parent is not NPbase");
1031}
1032
1034{
1035 if ((this->getModel()).isModelLinearized()) {
1036 return (1.0 + (myNPbase->BrHtautauRatio()) - (myNPbase->BrH4lRatio()));
1037 } else {
1038 return (myNPbase->BrHtautauRatio()) / (myNPbase->BrH4lRatio());
1039 }
1040}
1041
1042
1044{
1045 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1046 throw std::runtime_error("BrHtogaga_over_2e2mu_Ratio called with a class whose parent is not NPbase");
1047}
1048
1050{
1051 if ((this->getModel()).isModelLinearized()) {
1052 return (1.0 + (myNPbase->BrHgagaRatio()) - (myNPbase->BrH2e2muRatio()));
1053 } else {
1054 return (myNPbase->BrHgagaRatio()) / (myNPbase->BrH2e2muRatio());
1055 }
1056}
1057
1059{
1060 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1061 throw std::runtime_error("BrHtoZga_over_4l_Ratio called with a class whose parent is not NPbase");
1062}
1063
1065{
1066 if ((this->getModel()).isModelLinearized()) {
1067 return (1.0 + (myNPbase->BrHZgaRatio()) - (myNPbase->BrH4lRatio()));
1068 } else {
1069 return (myNPbase->BrHZgaRatio()) / (myNPbase->BrH4lRatio());
1070 }
1071}
1072
1074{
1075 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1076 throw std::runtime_error("BrHtomumu_over_4l_Ratio called with a class whose parent is not NPbase");
1077}
1078
1080{
1081 if ((this->getModel()).isModelLinearized()) {
1082 return (1.0 + (myNPbase->BrHmumuRatio()) - (myNPbase->BrH4lRatio()));
1083 } else {
1084 return (myNPbase->BrHmumuRatio()) / (myNPbase->BrH4lRatio());
1085 }
1086}
1087
1089{
1090 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1091 throw std::runtime_error("BrHtomumu_over_4mu_Ratio called with a class whose parent is not NPbase");
1092}
1093
1095{
1096 if ((this->getModel()).isModelLinearized()) {
1097 return (1.0 + (myNPbase->BrHmumuRatio()) - (myNPbase->BrH4muRatio()));
1098 } else {
1099 return (myNPbase->BrHmumuRatio()) / (myNPbase->BrH4muRatio());
1100 }
1101}
1102
1104{
1105 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1106 throw std::runtime_error("BrHto4l_over_gaga_Ratio called with a class whose parent is not NPbase");
1107}
1108
1110{
1111 if ((this->getModel()).isModelLinearized()) {
1112 return (1.0 + (myNPbase->BrH4lRatio()) - (myNPbase->BrHgagaRatio()));
1113 } else {
1114 return (myNPbase->BrH4lRatio()) / (myNPbase->BrHgagaRatio());
1115 }
1116}
1117
1119{
1120 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1121 throw std::runtime_error("BrHtoZga_over_gaga_Ratio called with a class whose parent is not NPbase");
1122}
1123
1125{
1126 if ((this->getModel()).isModelLinearized()) {
1127 return (1.0 + (myNPbase->BrHZgaRatio()) - (myNPbase->BrHgagaRatio()));
1128 } else {
1129 return (myNPbase->BrHZgaRatio()) / (myNPbase->BrHgagaRatio());
1130 }
1131}
1132
1134{
1135 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1136 throw std::runtime_error("BrHtomumu_over_gaga_Ratio called with a class whose parent is not NPbase");
1137}
1138
1140{
1141 if ((this->getModel()).isModelLinearized()) {
1142 return (1.0 + (myNPbase->BrHmumuRatio()) - (myNPbase->BrHgagaRatio()));
1143 } else {
1144 return (myNPbase->BrHmumuRatio()) / (myNPbase->BrHgagaRatio());
1145 }
1146}
1147
1148
1150{
1151 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1152 throw std::runtime_error("BrHto2l2v_over_gaga_Ratio called with a class whose parent is not NPbase");
1153}
1154
1156{
1157 if ((this->getModel()).isModelLinearized()) {
1158 return (1.0 + (myNPbase->BrH2l2vRatio()) - (myNPbase->BrHgagaRatio()));
1159 } else {
1160 return (myNPbase->BrH2l2vRatio()) / (myNPbase->BrHgagaRatio());
1161 }
1162}
1163
1164
1166{
1167 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1168 throw std::runtime_error("BrHtobb_over_cc_Ratio called with a class whose parent is not NPbase");
1169}
1170
1172{
1173 if ((this->getModel()).isModelLinearized()) {
1174 return (1.0 + (myNPbase->BrHbbRatio()) - (myNPbase->BrHccRatio()));
1175 } else {
1176 return (myNPbase->BrHbbRatio()) / (myNPbase->BrHccRatio());
1177 }
1178}
1179
1180
1182{
1183 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1184 throw std::runtime_error("BrHtogaga_over_gg_Ratio called with a class whose parent is not NPbase");
1185}
1186
1188{
1189 if ((this->getModel()).isModelLinearized()) {
1190 return (1.0 + (myNPbase->BrHgagaRatio()) - (myNPbase->BrHggRatio()));
1191 } else {
1192 return (myNPbase->BrHgagaRatio()) / (myNPbase->BrHggRatio());
1193 }
1194}
1195
1196
1198{
1199 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1200 throw std::runtime_error("BrHtogg_over_bb_Ratio called with a class whose parent is not NPbase");
1201}
1202
1204{
1205 if ((this->getModel()).isModelLinearized()) {
1206 return (1.0 + (myNPbase->BrHggRatio()) - (myNPbase->BrHbbRatio()));
1207 } else {
1208 return (myNPbase->BrHggRatio()) / (myNPbase->BrHbbRatio());
1209 }
1210}
1211
1212
1214{
1215 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1216 throw std::runtime_error("BrHtogg_over_cc_Ratio called with a class whose parent is not NPbase");
1217}
1218
1220{
1221 if ((this->getModel()).isModelLinearized()) {
1222 return (1.0 + (myNPbase->BrHggRatio()) - (myNPbase->BrHccRatio()));
1223 } else {
1224 return (myNPbase->BrHggRatio()) / (myNPbase->BrHccRatio());
1225 }
1226}
1227
1228
1229// -----------------------------------------------------------------------------
1230// Full signal strengths (prod x decay)
1231// -----------------------------------------------------------------------------
1232
1233muggHgaga::muggHgaga(const StandardModel& SM_i, const double sqrt_s_i)
1234: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1235{
1236 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1237 throw std::runtime_error("muggHgaga called with a class whose parent is not NPbase");
1238}
1239
1241{
1242 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1243 //AG: Most general expression including quadratic corrections.
1244 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1245 //return ( -1.0 + (myNPbase->muggH(sqrt_s)) + (myNPbase->BrHgagaRatio()));
1246 double muProd1 = myNPbase->delta_muggH_1(sqrt_s);
1247 double muProd2 = myNPbase->delta_muggH_2(sqrt_s);
1248 double dGammaR1 = myNPbase->deltaGammaHgagaRatio1();
1249 double dGammaR2 = myNPbase->deltaGammaHgagaRatio2();
1250
1251 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1252 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1253 double Br1 = dGammaR1-dGammaRTot1;
1254 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1255 return ( 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1) );
1256 } else {
1257 return myNPbase->muggHgaga(sqrt_s);
1258 }
1259}
1260
1261muggHgagaInt::muggHgagaInt(const StandardModel& SM_i, const double sqrt_s_i)
1262: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1263{
1264 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1265 throw std::runtime_error("muggHgagaInt called with a class whose parent is not NPbase");
1266}
1267
1269{
1271}
1272
1273muVBFHgaga::muVBFHgaga(const StandardModel& SM_i, const double sqrt_s_i)
1274: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1275{
1276 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1277 throw std::runtime_error("muVBFHgaga called with a class whose parent is not NPbase");
1278}
1279
1281{
1282 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1283 //AG: Most general expression including quadratic corrections.
1284 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1285 //return ( -1.0 + (myNPbase->muVBF(sqrt_s)) + (myNPbase->BrHgagaRatio()));
1286 double muProd1 = myNPbase->delta_muVBF_1(sqrt_s);
1287 double muProd2 = myNPbase->delta_muVBF_2(sqrt_s);
1288 double dGammaR1 = myNPbase->deltaGammaHgagaRatio1();
1289 double dGammaR2 = myNPbase->deltaGammaHgagaRatio2();
1290
1291 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1292 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1293 double Br1 = dGammaR1-dGammaRTot1;
1294 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1295
1296 double mu;
1297
1298 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1299
1300 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1301
1302 return mu;
1303 } else {
1304 return myNPbase->muVBFHgaga(sqrt_s);
1305 }
1306}
1307
1308muZHgaga::muZHgaga(const StandardModel& SM_i, const double sqrt_s_i)
1309: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1310{
1311 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1312 throw std::runtime_error("muZHgaga called with a class whose parent is not NPbase");
1313}
1314
1316{
1317 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1318 //AG: Most general expression including quadratic corrections.
1319 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1320 //return ( -1.0 + (myNPbase->muZH(sqrt_s)) + (myNPbase->BrHgagaRatio()));
1321 double muProd1 = myNPbase->delta_muZH_1(sqrt_s);
1322 double muProd2 = myNPbase->delta_muZH_2(sqrt_s);
1323 double dGammaR1 = myNPbase->deltaGammaHgagaRatio1();
1324 double dGammaR2 = myNPbase->deltaGammaHgagaRatio2();
1325
1326 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1327 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1328 double Br1 = dGammaR1-dGammaRTot1;
1329 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1330
1331 double mu;
1332
1333 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1334
1335 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1336
1337 return mu;
1338
1339 } else {
1340 return myNPbase->muZHgaga(sqrt_s);
1341 }
1342}
1343
1344muWHgaga::muWHgaga(const StandardModel& SM_i, const double sqrt_s_i)
1345: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1346{
1347 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1348 throw std::runtime_error("muWHgaga called with a class whose parent is not NPbase");
1349}
1350
1352{
1353 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1354 //AG: Most general expression including quadratic corrections.
1355 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1356 //return ( -1.0 + (myNPbase->muWH(sqrt_s)) + (myNPbase->BrHgagaRatio()));
1357 double muProd1 = myNPbase->delta_muWH_1(sqrt_s);
1358 double muProd2 = myNPbase->delta_muWH_2(sqrt_s);
1359 double dGammaR1 = myNPbase->deltaGammaHgagaRatio1();
1360 double dGammaR2 = myNPbase->deltaGammaHgagaRatio2();
1361
1362 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1363 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1364 double Br1 = dGammaR1-dGammaRTot1;
1365 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1366
1367 double mu;
1368
1369 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1370
1371 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1372
1373 return mu;
1374
1375 } else {
1376 return myNPbase->muWHgaga(sqrt_s);
1377 }
1378}
1379
1380muVHgaga::muVHgaga(const StandardModel& SM_i, const double sqrt_s_i)
1381: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1382{
1383 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1384 throw std::runtime_error("muVHgaga called with a class whose parent is not NPbase");
1385}
1386
1388{
1389 if ((this->getModel()).isModelLinearized()) {
1390 return ( -1.0 + (myNPbase->muVH(sqrt_s)) + (myNPbase->BrHgagaRatio()));
1391 } else {
1392 return myNPbase->muVHgaga(sqrt_s);
1393 }
1394}
1395
1396muttHgaga::muttHgaga(const StandardModel& SM_i, const double sqrt_s_i)
1397: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1398{
1399 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1400 throw std::runtime_error("muttHgaga called with a class whose parent is not NPbase");
1401}
1402
1404{
1405 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1406 //AG: Most general expression including quadratic corrections.
1407 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1408 //return ( -1.0 + (myNPbase->muttH(sqrt_s)) + (myNPbase->BrHgagaRatio()));
1409 double muProd1 = myNPbase->delta_muttH_1(sqrt_s);
1410 double muProd2 = myNPbase->delta_muttH_2(sqrt_s);
1411 double dGammaR1 = myNPbase->deltaGammaHgagaRatio1();
1412 double dGammaR2 = myNPbase->deltaGammaHgagaRatio2();
1413
1414 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1415 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1416 double Br1 = dGammaR1-dGammaRTot1;
1417 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1418
1419 double mu;
1420
1421 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1422
1423 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1424
1425 return mu;
1426
1427 } else {
1428 return myNPbase->muttHgaga(sqrt_s);
1429 }
1430}
1431
1432mutHgaga::mutHgaga(const StandardModel& SM_i, const double sqrt_s_i) //AG:added
1433: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1434{
1435 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1436 throw std::runtime_error("mutHgaga called with a class whose parent is not NPbase");
1437}
1438
1440{
1441 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1442 //AG: Most general expression including quadratic corrections.
1443 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1444 double muProd1 = myNPbase->delta_mutH_1(sqrt_s);
1445 double muProd2 = myNPbase->delta_mutH_2(sqrt_s);
1446 double dGammaR1 = myNPbase->deltaGammaHgagaRatio1();
1447 double dGammaR2 = myNPbase->deltaGammaHgagaRatio2();
1448
1449 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1450 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1451 double Br1 = dGammaR1-dGammaRTot1;
1452 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1453
1454 double mu;
1455
1456 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1457
1458 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1459
1460 return mu;
1461
1462 } else {
1463 //VM: Just in case someone wants to add directly the production*decay
1464 //(which is the observable we fit at the end)
1465 double NPmutHgaga = myNPbase->mutHgaga(sqrt_s);
1466 if(NPmutHgaga==1.0){
1467 return ((myNPbase->mutH(sqrt_s)) )*(myNPbase->BrHgagaRatio());
1468 } else{
1469 return NPmutHgaga;
1470 }
1471 }
1472}
1473
1474muggHpbbH_Hgaga::muggHpbbH_Hgaga(const StandardModel& SM_i, const double sqrt_s_i) //AG:added
1475: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1476{
1477 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1478 throw std::runtime_error("muggHpbbH_Hgaga called with a class whose parent is not NPbase");
1479}
1480
1482{
1483 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1484 //AG: Most general expression including quadratic corrections.
1485 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1486 double muProd1 = myNPbase->delta_muggH_1(sqrt_s);
1487 double muProd2 = myNPbase->delta_muggH_2(sqrt_s);
1488 double dGammaR1 = myNPbase->deltaGammaHgagaRatio1();
1489 double dGammaR2 = myNPbase->deltaGammaHgagaRatio2();
1490
1491 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1492 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1493 double Br1 = dGammaR1-dGammaRTot1;
1494 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1495
1496 double mu;
1497
1498 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1499
1500 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1501
1502 return mu;
1503
1504 } else {
1505 //VM: Just in case someone wants to add directly the production*decay
1506 //(which is the observable we fit at the end)
1507 //Also, the bbH is missing here, I'll leave it as it was for the
1508 //moment (since bbH is really suppressed).
1509 double NPmuggHpbbH_Hgaga = myNPbase->muggHpbbH_Hgaga(sqrt_s);
1510 if (NPmuggHpbbH_Hgaga == 1.0){
1511 return (myNPbase->muggHgaga(sqrt_s));
1512 } else{
1513 return NPmuggHpbbH_Hgaga;
1514 }
1515 }
1516}
1517
1518muttHptH_Hgaga::muttHptH_Hgaga(const StandardModel& SM_i, const double sqrt_s_i)//AG:added
1519: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1520{
1521 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1522 throw std::runtime_error("muttHptH_Hgaga called with a class whose parent is not NPbase");
1523}
1524
1526{
1527 //VM:Note that these values are valid for 13 TeV, they are not general
1528 //We should access the SM function that has all the values (for the
1529 //different energies). The values are slightly different, we should
1530 //check this.
1531 //Ref: https://www.hepdata.net/record/ins2104706 Figure2a (symmetrized)
1532 double xsSM_ttH = 0.499873;
1533 double xsSM_tH = 0.0821;
1534 //double xsSM_ttH = myNPbase->computeSigmattH(sqrt_s);
1535 //double xsSM_tH = myNPbase->computeSigmatHq(sqrt_s);
1536
1537 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1538 //AG: Most general expression including quadratic corrections.
1539 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1540 double muProd1 = ( xsSM_ttH*(myNPbase->delta_muttH_1(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_1(sqrt_s)) )/(xsSM_ttH+xsSM_tH);
1541 double muProd2 = ( xsSM_ttH*(myNPbase->delta_muttH_2(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_2(sqrt_s)) )/(xsSM_ttH+xsSM_tH);
1542 double dGammaR1 = myNPbase->deltaGammaHgagaRatio1();
1543 double dGammaR2 = myNPbase->deltaGammaHgagaRatio2();
1544
1545 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1546 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1547 double Br1 = dGammaR1-dGammaRTot1;
1548 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1549
1550 double mu;
1551
1552 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1553
1554 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1555
1556 return mu;
1557
1558 } else {
1559 //VM: Just in case someone wants to add directly the production*decay
1560 //(which is the observable we fit at the end)
1561 double NPmuttHptH_Hgaga = myNPbase->muttHptH_Hgaga(sqrt_s);
1562 if(NPmuttHptH_Hgaga==1.0){
1563 return ( xsSM_ttH*(myNPbase->muttH(sqrt_s)) + xsSM_tH*(myNPbase->mutH(sqrt_s)) )/(xsSM_ttH+xsSM_tH) * (myNPbase->BrHgagaRatio()) ;
1564 } else {
1565 return NPmuttHptH_Hgaga;
1566 }
1567 }
1568}
1569
1570muggHZga::muggHZga(const StandardModel& SM_i, const double sqrt_s_i)
1571: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1572{
1573 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1574 throw std::runtime_error("muggHZga called with a class whose parent is not NPbase");
1575}
1576
1578{
1579 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1580 //return ( -1.0 + (myNPbase->muggH(sqrt_s)) + (myNPbase->BrHZgaRatio()));
1581 //AG: Most general expression including quadratic corrections.
1582 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1583 double muProd1 = myNPbase->delta_muggH_1(sqrt_s);
1584 double muProd2 = myNPbase->delta_muggH_2(sqrt_s);
1585 double dGammaR1 = myNPbase->deltaGammaHZgaRatio1();
1586 double dGammaR2 = myNPbase->deltaGammaHZgaRatio2();
1587
1588 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1589 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1590 double Br1 = dGammaR1-dGammaRTot1;
1591 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1592
1593 double mu;
1594
1595 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1596
1597 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1598
1599 return mu;
1600
1601 } else {
1602 return myNPbase->muggHZga(sqrt_s);
1603 }
1604}
1605
1606muggHZgamumu::muggHZgamumu(const StandardModel& SM_i, const double sqrt_s_i)
1607: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1608{
1609 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1610 throw std::runtime_error("muggHZgamumu called with a class whose parent is not NPbase");
1611}
1612
1614{
1615 if ((this->getModel()).isModelLinearized()) {
1616 return ( -1.0 + (myNPbase->muggH(sqrt_s)) + (myNPbase->BrHZgamumuRatio()));
1617 } else {
1619 }
1620}
1621
1622muVBFHZga::muVBFHZga(const StandardModel& SM_i, const double sqrt_s_i)
1623: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1624{
1625 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1626 throw std::runtime_error("muVBFHZga called with a class whose parent is not NPbase");
1627}
1628
1630{
1631 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1632 //return ( -1.0 + (myNPbase->muVBF(sqrt_s)) + (myNPbase->BrHZgaRatio()));
1633 //AG: Most general expression including quadratic corrections.
1634 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1635 double muProd1 = myNPbase->delta_muVBF_1(sqrt_s);
1636 double muProd2 = myNPbase->delta_muVBF_2(sqrt_s);
1637 double dGammaR1 = myNPbase->deltaGammaHZgaRatio1();
1638 double dGammaR2 = myNPbase->deltaGammaHZgaRatio2();
1639
1640 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1641 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1642 double Br1 = dGammaR1-dGammaRTot1;
1643 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1644
1645 double mu;
1646
1647 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1648
1649 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1650
1651 return mu;
1652
1653 } else {
1654 return myNPbase->muVBFHZga(sqrt_s);
1655 }
1656}
1657
1658muZHZga::muZHZga(const StandardModel& SM_i, const double sqrt_s_i)
1659: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1660{
1661 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1662 throw std::runtime_error("muZHZga called with a class whose parent is not NPbase");
1663}
1664
1666{
1667 if ((this->getModel()).isModelLinearized()) {
1668 return ( -1.0 + (myNPbase->muZH(sqrt_s)) + (myNPbase->BrHZgaRatio()));
1669 } else {
1670 return myNPbase->muZHZga(sqrt_s);
1671 }
1672}
1673
1674muWHZga::muWHZga(const StandardModel& SM_i, const double sqrt_s_i)
1675: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1676{
1677 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1678 throw std::runtime_error("muWHZga called with a class whose parent is not NPbase");
1679}
1680
1682{
1683 if ((this->getModel()).isModelLinearized()) {
1684 return ( -1.0 + (myNPbase->muWH(sqrt_s)) + (myNPbase->BrHZgaRatio()));
1685 } else {
1686 return myNPbase->muWHZga(sqrt_s);
1687 }
1688}
1689
1690muVHZga::muVHZga(const StandardModel& SM_i, const double sqrt_s_i)
1691: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1692{
1693 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1694 throw std::runtime_error("muVHZga called with a class whose parent is not NPbase");
1695}
1696
1698{
1699 if ((this->getModel()).isModelLinearized()) {
1700 return ( -1.0 + (myNPbase->muVH(sqrt_s)) + (myNPbase->BrHZgaRatio()));
1701 } else {
1702 return myNPbase->muVHZga(sqrt_s);
1703 }
1704}
1705
1706muttHZga::muttHZga(const StandardModel& SM_i, const double sqrt_s_i)
1707: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1708{
1709 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1710 throw std::runtime_error("muttHZga called with a class whose parent is not NPbase");
1711}
1712
1714{
1715 if ((this->getModel()).isModelLinearized()) {
1716 return ( -1.0 + (myNPbase->muttH(sqrt_s)) + (myNPbase->BrHZgaRatio()));
1717 } else {
1718 return myNPbase->muttHZga(sqrt_s);
1719 }
1720}
1721
1722muggHZZ::muggHZZ(const StandardModel& SM_i, const double sqrt_s_i)
1723: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1724{
1725 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1726 throw std::runtime_error("muggHZZ called with a class whose parent is not NPbase");
1727}
1728
1730{
1731 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1732 //return ( -1.0 + (myNPbase->muggH(sqrt_s)) + (myNPbase->BrHZZRatio()));
1733 //AG: Most general expression including quadratic corrections.
1734 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1735 double muProd1 = myNPbase->delta_muggH_1(sqrt_s);
1736 double muProd2 = myNPbase->delta_muggH_2(sqrt_s);
1737 double dGammaR1 = myNPbase->deltaGammaHZZRatio1();
1738 double dGammaR2 = myNPbase->deltaGammaHZZRatio2();
1739
1740 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1741 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1742 double Br1 = dGammaR1-dGammaRTot1;
1743 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1744
1745 double mu;
1746
1747 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1748
1749 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1750
1751 return mu;
1752
1753 } else {
1754 return myNPbase->muggHZZ(sqrt_s);
1755 }
1756}
1757
1758muVBFHZZ::muVBFHZZ(const StandardModel& SM_i, const double sqrt_s_i)
1759: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1760{
1761 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1762 throw std::runtime_error("muVBFHZZ called with a class whose parent is not NPbase");
1763}
1764
1766{
1767 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1768 //AG: Most general expression including quadratic corrections.
1769 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1770 //return ( -1.0 + (myNPbase->muVBF(sqrt_s)) + (myNPbase->BrHZZRatio()));
1771 double muProd1 = myNPbase->delta_muVBF_1(sqrt_s);
1772 double muProd2 = myNPbase->delta_muVBF_2(sqrt_s);
1773 double dGammaR1 = myNPbase->deltaGammaHZZRatio1();
1774 double dGammaR2 = myNPbase->deltaGammaHZZRatio2();
1775
1776 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1777 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1778 double Br1 = dGammaR1-dGammaRTot1;
1779 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1780
1781 double mu;
1782
1783 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1784
1785 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1786
1787 return mu;
1788
1789 } else {
1790 return myNPbase->muVBFHZZ(sqrt_s);
1791 }
1792}
1793
1794muZHZZ::muZHZZ(const StandardModel& SM_i, const double sqrt_s_i)
1795: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1796{
1797 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1798 throw std::runtime_error("muZHZZ called with a class whose parent is not NPbase");
1799}
1800
1802{
1803 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1804 //return ( -1.0 + (myNPbase->muZH(sqrt_s)) + (myNPbase->BrHZZRatio()));
1805 //AG: Most general expression including quadratic corrections.
1806 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1807 double muProd1 = myNPbase->delta_muZH_1(sqrt_s);
1808 double muProd2 = myNPbase->delta_muZH_2(sqrt_s);
1809 double dGammaR1 = myNPbase->deltaGammaHZZRatio1();
1810 double dGammaR2 = myNPbase->deltaGammaHZZRatio2();
1811
1812 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1813 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1814 double Br1 = dGammaR1-dGammaRTot1;
1815 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1816
1817 double mu;
1818
1819 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1820
1821 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1822
1823 return mu;
1824
1825 } else {
1826 return myNPbase->muZHZZ(sqrt_s);
1827 }
1828}
1829
1830muWHZZ::muWHZZ(const StandardModel& SM_i, const double sqrt_s_i)
1831: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1832{
1833 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1834 throw std::runtime_error("muWHZZ called with a class whose parent is not NPbase");
1835}
1836
1838{
1839 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1840 //return ( -1.0 + (myNPbase->muWH(sqrt_s)) + (myNPbase->BrHZZRatio()));
1841 //AG: Most general expression including quadratic corrections.
1842 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1843 double muProd1 = myNPbase->delta_muWH_1(sqrt_s);
1844 double muProd2 = myNPbase->delta_muWH_2(sqrt_s);
1845 double dGammaR1 = myNPbase->deltaGammaHZZRatio1();
1846 double dGammaR2 = myNPbase->deltaGammaHZZRatio2();
1847
1848 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1849 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1850 double Br1 = dGammaR1-dGammaRTot1;
1851 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1852
1853 double mu;
1854
1855 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1856
1857 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1858
1859 return mu;
1860
1861 } else {
1862 return myNPbase->muWHZZ(sqrt_s);
1863 }
1864}
1865
1866muVHZZ::muVHZZ(const StandardModel& SM_i, const double sqrt_s_i)
1867: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1868{
1869 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1870 throw std::runtime_error("muVHZZ called with a class whose parent is not NPbase");
1871}
1872
1874{
1875 //VM:Note that these values are valid for 13 TeV, they are not general
1876 //We should access the SM function that has all the values (for the
1877 //different energies). The values are slightly different, we should
1878 //check this.
1879 //Ref: https://www.hepdata.net/record/ins2104706 Figure2a (symmetrized)
1880 double xsSM_WH = 1.21539;
1881 double xsSM_ZH = 0.795910;
1882 //double xsSM_WH = myNPbase->computeSigmaWH(sqrt_s);
1883 //double xsSM_ZH = myNPbase->computeSigmaZH(sqrt_s);
1884 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1885 //AG: Most general expression including quadratic corrections.
1886 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1887 //return ( -1.0 + (myNPbase->muVH(sqrt_s)) + (myNPbase->BrHZZRatio()));
1888 double muProd1 = ( xsSM_ZH*(myNPbase->delta_muZH_1(sqrt_s)) + xsSM_WH*(myNPbase->delta_muWH_1(sqrt_s)) )/(xsSM_ZH+xsSM_WH);
1889 double muProd2 = ( xsSM_ZH*(myNPbase->delta_muZH_2(sqrt_s)) + xsSM_WH*(myNPbase->delta_muWH_2(sqrt_s)) )/(xsSM_ZH+xsSM_WH);
1890 double dGammaR1 = myNPbase->deltaGammaHZZRatio1();
1891 double dGammaR2 = myNPbase->deltaGammaHZZRatio2();
1892
1893 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1894 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1895 double Br1 = dGammaR1-dGammaRTot1;
1896 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1897
1898 double mu;
1899
1900 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1901
1902 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1903
1904 return mu;
1905
1906 } else {
1907 //return myNPbase->muVHZZ(sqrt_s);
1908 //VM: Just in case someone wants to add directly the production*decay
1909 //(which is the observable we fit at the end)
1910 double NPmuVHZZ = myNPbase->muVHZZ(sqrt_s);
1911 if(NPmuVHZZ==1.0){
1912 return ( xsSM_ZH*(myNPbase->muZH(sqrt_s)) + xsSM_WH*(myNPbase->muWH(sqrt_s)) )/(xsSM_ZH+xsSM_WH) * (myNPbase->BrHZZRatio());
1913 } else {
1914 return NPmuVHZZ;
1915 }
1916 }
1917}
1918
1919muttHZZ::muttHZZ(const StandardModel& SM_i, const double sqrt_s_i)
1920: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1921{
1922 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1923 throw std::runtime_error("muttHZZ called with a class whose parent is not NPbase");
1924}
1925
1927{
1928 if ((this->getModel()).isModelLinearized()) {
1929 return ( -1.0 + (myNPbase->muttH(sqrt_s)) + (myNPbase->BrHZZRatio()));
1930 } else {
1931 return myNPbase->muttHZZ(sqrt_s);
1932 }
1933}
1934
1935muttHptH_HZZ::muttHptH_HZZ(const StandardModel& SM_i, const double sqrt_s_i) //AG:added
1936: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1937{
1938 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1939 throw std::runtime_error("muttHptH_HZZ called with a class whose parent is not NPbase");
1940}
1941
1943{
1944 //VM:Note that these values are valid for 13 TeV, they are not general
1945 //We should access the SM function that has all the values (for the
1946 //different energies). The values are slightly different, we should
1947 //check this.
1948 //Ref: https://www.hepdata.net/record/ins2104706 Figure2a (symmetrized)
1949 double xsSM_ttH = 0.499873;
1950 double xsSM_tH = 0.0821;
1951 //double xsSM_ttH = myNPbase->computeSigmattH(sqrt_s);
1952 //double xsSM_tH = myNPbase->computeSigmatHq(sqrt_s);
1953 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
1954 //AG: Most general expression including quadratic corrections.
1955 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
1956 //return ( 1.0 + muProd1 + (myNPbase->BrHZZRatio()-1.) );
1957 double muProd1 = ( xsSM_ttH*(myNPbase->delta_muttH_1(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_1(sqrt_s)) )/(xsSM_ttH+xsSM_tH);
1958 double muProd2 = ( xsSM_ttH*(myNPbase->delta_muttH_2(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_2(sqrt_s)) )/(xsSM_ttH+xsSM_tH);
1959 double dGammaR1 = myNPbase->deltaGammaHZZRatio1();
1960 double dGammaR2 = myNPbase->deltaGammaHZZRatio2();
1961
1962 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
1963 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
1964 double Br1 = dGammaR1-dGammaRTot1;
1965 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1966
1967 double mu;
1968
1969 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1970
1971 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
1972
1973 return mu;
1974
1975 } else {
1976
1977 //VM: Just in case someone wants to add directly the production*decay
1978 //(which is the observable we fit at the end)
1979 double NPmuttHptH_HZZ = myNPbase->muttHptH_HZZ(sqrt_s);
1980 if(NPmuttHptH_HZZ==1.0){
1981 return ( xsSM_ttH*(myNPbase->muttH(sqrt_s)) + xsSM_tH*(myNPbase->mutH(sqrt_s)) )/(xsSM_ttH+xsSM_tH) * (myNPbase->BrHZZRatio()) ;
1982 } else {
1983 return NPmuttHptH_HZZ;
1984 }
1985 }
1986}
1987
1988muttHptH_Hmumu::muttHptH_Hmumu(const StandardModel& SM_i, const double sqrt_s_i)//AG:added
1989: ThObservable(SM_i), sqrt_s(sqrt_s_i)
1990{
1991 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
1992 throw std::runtime_error("muttHptH_Hmumu called with a class whose parent is not NPbase");
1993}
1994
1996{
1997 //VM:Note that these values are valid for 13 TeV, they are not general
1998 //We should access the SM function that has all the values (for the
1999 //different energies). The values are slightly different, we should
2000 //check this.
2001 //Ref: https://www.hepdata.net/record/ins2104706 Figure2a (symmetrized)
2002 double xsSM_ttH = 0.499873;
2003 double xsSM_tH = 0.0821;
2004 //double xsSM_ttH = myNPbase->computeSigmattH(sqrt_s);
2005 //double xsSM_tH = myNPbase->computeSigmatHq(sqrt_s);
2006 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2007 //return ( 1.0
2008 // + ( xsSM_ttH*(myNPbase->muttH(sqrt_s)-1.) + xsSM_tH*(myNPbase->mutH(sqrt_s)-1.) )/(xsSM_ttH+xsSM_tH)
2009 // + (myNPbase->BrHmumuRatio()-1.));
2010 double muProd1 = ( xsSM_ttH*(myNPbase->muttH(sqrt_s)-1.) + xsSM_tH*(myNPbase->mutH(sqrt_s)-1.) )/(xsSM_ttH+xsSM_tH);
2011 double muProd2 = ( xsSM_ttH*(myNPbase->delta_muttH_2(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_2(sqrt_s)) )/(xsSM_ttH+xsSM_tH);
2012 double dGammaR1 = myNPbase->deltaGammaHmumuRatio1();
2013 double dGammaR2 = myNPbase->deltaGammaHmumuRatio2();
2014
2015 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2016 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2017 double Br1 = dGammaR1-dGammaRTot1;
2018 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2019
2020 double mu;
2021
2022 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2023
2024 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2025
2026 return mu;
2027
2028 } else {
2029
2030 //VM: Just in case someone wants to add directly the production*decay
2031 //(which is the observable we fit at the end)
2032 double NPmuttHptH_Hmumu = myNPbase->muttHptH_Hmumu(sqrt_s);
2033 if(NPmuttHptH_Hmumu==1.0){
2034 return ( xsSM_ttH*(myNPbase->muttH(sqrt_s)) + xsSM_tH*(myNPbase->mutH(sqrt_s)) )/(xsSM_ttH+xsSM_tH) * (myNPbase->BrHmumuRatio());
2035 } else {
2036 return NPmuttHptH_Hmumu;
2037 }
2038 }
2039}
2040
2041muggHpbbH_HZZ::muggHpbbH_HZZ(const StandardModel& SM_i, const double sqrt_s_i) //AG:added
2042: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2043{
2044 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2045 throw std::runtime_error("muggHpbbH_HZZ called with a class whose parent is not NPbase");
2046}
2047
2049{
2050 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2051 //AG: Most general expression including quadratic corrections.
2052 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2053 //return ( 1.0 + (myNPbase->muggH(sqrt_s)-1.) + (myNPbase->BrHZZRatio()-1.));
2054 double muProd1 = myNPbase->delta_muggH_1(sqrt_s);
2055 double muProd2 = myNPbase->delta_muggH_2(sqrt_s);
2056 double dGammaR1 = myNPbase->deltaGammaHZZRatio1();
2057 double dGammaR2 = myNPbase->deltaGammaHZZRatio2();
2058
2059 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2060 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2061 double Br1 = dGammaR1-dGammaRTot1;
2062 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2063
2064 double mu;
2065
2066 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2067
2068 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2069
2070 return mu;
2071
2072 } else {
2073 //VM: Just in case someone wants to add directly the production*decay
2074 //(which is the observable we fit at the end)
2075 //Also, the bbH is missing here, I'll leave it as it was for the
2076 //moment (since bbH is really suppressed in the SM).
2077 double NPmuggHpbbH_HZZ = myNPbase->muggHpbbH_HZZ(sqrt_s);
2078 if (NPmuggHpbbH_HZZ == 1.0){
2079 return (myNPbase->muggHZZ(sqrt_s));
2080 } else{
2081 return NPmuggHpbbH_HZZ;
2082 }
2083 }
2084}
2085
2086muggHZZ4l::muggHZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
2087: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2088{
2089 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2090 throw std::runtime_error("muggHZZ4l called with a class whose parent is not NPbase");
2091}
2092
2094{
2095 if ((this->getModel()).isModelLinearized()) {
2096 return ( -1.0 + (myNPbase->muggH(sqrt_s)) + (myNPbase->BrH4lRatio()));
2097 } else {
2098 return myNPbase->muggHZZ4l(sqrt_s);
2099 }
2100}
2101
2102muggHZZ4mu::muggHZZ4mu(const StandardModel& SM_i, const double sqrt_s_i)
2103: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2104{
2105 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2106 throw std::runtime_error("muggHZZ4mu called with a class whose parent is not NPbase");
2107}
2108
2110{
2111 if ((this->getModel()).isModelLinearized()) {
2112 return ( -1.0 + (myNPbase->muggH(sqrt_s)) + (myNPbase->BrH4muRatio()));
2113 } else {
2114 return (myNPbase->muggH(sqrt_s))*(myNPbase->BrH4muRatio());
2115 }
2116}
2117
2118muVBFHZZ4l::muVBFHZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
2119: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2120{
2121 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2122 throw std::runtime_error("muVBFHZZ4l called with a class whose parent is not NPbase");
2123}
2124
2126{
2127 if ((this->getModel()).isModelLinearized()) {
2128 return ( -1.0 + (myNPbase->muVBF(sqrt_s)) + (myNPbase->BrH4lRatio()));
2129 } else {
2130 return myNPbase->muVBFHZZ4l(sqrt_s);
2131 }
2132}
2133
2134muZHZZ4l::muZHZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
2135: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2136{
2137 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2138 throw std::runtime_error("muZHZZ4l called with a class whose parent is not NPbase");
2139}
2140
2142{
2143 if ((this->getModel()).isModelLinearized()) {
2144 return ( -1.0 + (myNPbase->muZH(sqrt_s)) + (myNPbase->BrH4lRatio()));
2145 } else {
2146 return myNPbase->muZHZZ4l(sqrt_s);
2147 }
2148}
2149
2150muWHZZ4l::muWHZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
2151: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2152{
2153 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2154 throw std::runtime_error("muWHZZ4l called with a class whose parent is not NPbase");
2155}
2156
2158{
2159 if ((this->getModel()).isModelLinearized()) {
2160 return ( -1.0 + (myNPbase->muWH(sqrt_s)) + (myNPbase->BrH4lRatio()));
2161 } else {
2162 return myNPbase->muWHZZ4l(sqrt_s);
2163 }
2164}
2165
2166muVHZZ4l::muVHZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
2167: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2168{
2169 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2170 throw std::runtime_error("muVHZZ4l called with a class whose parent is not NPbase");
2171}
2172
2174{
2175 if ((this->getModel()).isModelLinearized()) {
2176 return ( -1.0 + (myNPbase->muVH(sqrt_s)) + (myNPbase->BrH4lRatio()));
2177 } else {
2178 return myNPbase->muVHZZ4l(sqrt_s);
2179 }
2180}
2181
2182muttHZZ4l::muttHZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
2183: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2184{
2185 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2186 throw std::runtime_error("muttHZZ4l called with a class whose parent is not NPbase");
2187}
2188
2190{
2191 if ((this->getModel()).isModelLinearized()) {
2192 return ( -1.0 + (myNPbase->muttH(sqrt_s)) + (myNPbase->BrH4lRatio()));
2193 } else {
2194 return myNPbase->muttHZZ4l(sqrt_s);
2195 }
2196}
2197
2198muggHWW::muggHWW(const StandardModel& SM_i, const double sqrt_s_i)
2199: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2200{
2201 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2202 throw std::runtime_error("muggHWW called with a class whose parent is not NPbase");
2203}
2204
2206{
2207 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2208 //return ( -1.0 + (myNPbase->muggH(sqrt_s)) + (myNPbase->BrHWWRatio()));
2209 //AG: Most general expression including quadratic corrections.
2210 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2211 double muProd1 = myNPbase->delta_muggH_1(sqrt_s);
2212 double muProd2 = myNPbase->delta_muggH_2(sqrt_s);
2213 double dGammaR1 = myNPbase->deltaGammaHWWRatio1();
2214 double dGammaR2 = myNPbase->deltaGammaHWWRatio2();
2215
2216 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2217 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2218 double Br1 = dGammaR1-dGammaRTot1;
2219 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2220
2221 double mu;
2222
2223 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2224
2225 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2226
2227 return mu;
2228
2229 } else {
2230 return myNPbase->muggHWW(sqrt_s);
2231 }
2232}
2233
2234muVBFHWW::muVBFHWW(const StandardModel& SM_i, const double sqrt_s_i)
2235: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2236{
2237 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2238 throw std::runtime_error("muVBFHWW called with a class whose parent is not NPbase");
2239}
2240
2242{
2243 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2244 //AG: Most general expression including quadratic corrections.
2245 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2246 //return ( -1.0 + (myNPbase->muVBF(sqrt_s)) + (myNPbase->BrHWWRatio()));
2247 double muProd1 = myNPbase->delta_muVBF_1(sqrt_s);
2248 double muProd2 = myNPbase->delta_muVBF_2(sqrt_s);
2249 double dGammaR1 = myNPbase->deltaGammaHWWRatio1();
2250 double dGammaR2 = myNPbase->deltaGammaHWWRatio2();
2251
2252 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2253 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2254 double Br1 = dGammaR1-dGammaRTot1;
2255 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2256
2257 double mu;
2258
2259 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2260
2261 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2262
2263 return mu;
2264
2265 } else {
2266 return myNPbase->muVBFHWW(sqrt_s);
2267 }
2268}
2269
2270muZHWW::muZHWW(const StandardModel& SM_i, const double sqrt_s_i)
2271: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2272{
2273 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2274 throw std::runtime_error("muZHWW called with a class whose parent is not NPbase");
2275}
2276
2278{
2279 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2280 //AG: Most general expression including quadratic corrections.
2281 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2282 //return ( -1.0 + (myNPbase->muZH(sqrt_s)) + (myNPbase->BrHWWRatio()));
2283 double muProd1 = myNPbase->delta_muZH_1(sqrt_s);
2284 double muProd2 = myNPbase->delta_muZH_2(sqrt_s);
2285 double dGammaR1 = myNPbase->deltaGammaHWWRatio1();
2286 double dGammaR2 = myNPbase->deltaGammaHWWRatio2();
2287
2288 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2289 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2290 double Br1 = dGammaR1-dGammaRTot1;
2291 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2292
2293 double mu;
2294
2295 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2296
2297 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2298
2299 return mu;
2300
2301 } else {
2302 return myNPbase->muZHWW(sqrt_s);
2303 }
2304}
2305
2306muWHWW::muWHWW(const StandardModel& SM_i, const double sqrt_s_i)
2307: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2308{
2309 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2310 throw std::runtime_error("muWHWW called with a class whose parent is not NPbase");
2311}
2312
2314{
2315 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2316 //AG: Most general expression including quadratic corrections.
2317 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2318 //return ( -1.0 + (myNPbase->muWH(sqrt_s)) + (myNPbase->BrHWWRatio()));
2319 double muProd1 = myNPbase->delta_muWH_1(sqrt_s);
2320 double muProd2 = myNPbase->delta_muWH_2(sqrt_s);
2321 double dGammaR1 = myNPbase->deltaGammaHWWRatio1();
2322 double dGammaR2 = myNPbase->deltaGammaHWWRatio2();
2323
2324 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2325 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2326 double Br1 = dGammaR1-dGammaRTot1;
2327 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2328
2329 double mu;
2330
2331 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2332
2333 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2334
2335 return mu;
2336
2337 } else {
2338 return myNPbase->muWHWW(sqrt_s);
2339 }
2340}
2341
2342muVHWW::muVHWW(const StandardModel& SM_i, const double sqrt_s_i)
2343: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2344{
2345 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2346 throw std::runtime_error("muVHWW called with a class whose parent is not NPbase");
2347}
2348
2350{
2351 if ((this->getModel()).isModelLinearized()) {
2352 return ( -1.0 + (myNPbase->muVH(sqrt_s)) + (myNPbase->BrHWWRatio()));
2353 } else {
2354 return myNPbase->muVHWW(sqrt_s);
2355 }
2356}
2357
2358muttHWW::muttHWW(const StandardModel& SM_i, const double sqrt_s_i)
2359: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2360{
2361 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2362 throw std::runtime_error("muttHWW called with a class whose parent is not NPbase");
2363}
2364
2366{
2367 if ((this->getModel()).isModelLinearized()) {
2368 return ( -1.0 + (myNPbase->muttH(sqrt_s)) + (myNPbase->BrHWWRatio()));
2369 } else {
2370 return myNPbase->muttHWW(sqrt_s);
2371 }
2372}
2373
2374muttHptH_HWW::muttHptH_HWW(const StandardModel& SM_i, const double sqrt_s_i) //AG:added
2375: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2376{
2377 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2378 throw std::runtime_error("muttHptH_HWW called with a class whose parent is not NPbase");
2379}
2380
2382{
2383
2384 //VM:Note that these values are valid for 13 TeV, they are not general
2385 //We should access the SM function that has all the values (for the
2386 //different energies). The values are slightly different, we should
2387 //check this.
2388 //Ref: https://www.hepdata.net/record/ins2104706 Figure2a (symmetrized)
2389 double xsSM_ttH = 0.499873;
2390 double xsSM_tH = 0.0821;
2391 //double xsSM_ttH = myNPbase->computeSigmattH(sqrt_s);
2392 //double xsSM_tH = myNPbase->computeSigmatHq(sqrt_s);
2393 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2394 //AG: Most general expression including quadratic corrections.
2395 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2396 double muProd1 = ( xsSM_ttH*(myNPbase->delta_muttH_1(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_1(sqrt_s)) )/(xsSM_ttH+xsSM_tH);
2397 double muProd2 = ( xsSM_ttH*(myNPbase->delta_muttH_2(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_2(sqrt_s)) )/(xsSM_ttH+xsSM_tH);
2398 double dGammaR1 = myNPbase->deltaGammaHWWRatio1();
2399 double dGammaR2 = myNPbase->deltaGammaHWWRatio2();
2400
2401 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2402 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2403 double Br1 = dGammaR1-dGammaRTot1;
2404 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2405
2406 double mu;
2407
2408 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2409
2410 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2411
2412 return mu;
2413
2414 } else {
2415
2416 //VM: Just in case someone wants to add directly the production*decay
2417 //(which is the observable we fit at the end)
2418 double NPmuttHptH_HWW = myNPbase->muttHptH_HWW(sqrt_s);
2419 if(NPmuttHptH_HWW==1.0){
2420 return ( xsSM_ttH*(myNPbase->muttH(sqrt_s)) + xsSM_tH*(myNPbase->mutH(sqrt_s)) )/(xsSM_ttH+xsSM_tH) * (myNPbase->BrHWWRatio()) ;
2421 } else {
2422 return NPmuttHptH_HWW;
2423 }
2424 }
2425}
2426
2427muggHpbbH_HWW::muggHpbbH_HWW(const StandardModel& SM_i, const double sqrt_s_i) //AG:added
2428: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2429{
2430 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2431 throw std::runtime_error("muggHpbbH_HWW called with a class whose parent is not NPbase");
2432}
2433
2435{
2436 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2437 //AG: Most general expression including quadratic corrections.
2438 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2439 //return ( 1.0 + (myNPbase->muggH(sqrt_s)-1.) + (myNPbase->BrHWWRatio()-1.));
2440 double muProd1 = myNPbase->delta_muggH_1(sqrt_s);
2441 double muProd2 = myNPbase->delta_muggH_2(sqrt_s);
2442 double dGammaR1 = myNPbase->deltaGammaHWWRatio1();
2443 double dGammaR2 = myNPbase->deltaGammaHWWRatio2();
2444
2445 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2446 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2447 double Br1 = dGammaR1-dGammaRTot1;
2448 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2449
2450 double mu;
2451
2452 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2453
2454 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2455
2456 return mu;
2457
2458 } else {
2459
2460 //VM: Just in case someone wants to add directly the production*decay
2461 //(which is the observable we fit at the end)
2462 //Also, the bbH is missing here, I'll leave it as it was for the
2463 //moment (since bbH is really suppressed in the SM).
2464 double NPmuggHpbbH_HWW = myNPbase->muggHpbbH_HWW(sqrt_s);
2465 if (NPmuggHpbbH_HWW == 1.0){
2466 return (myNPbase->muggHWW(sqrt_s));
2467 } else{
2468 return NPmuggHpbbH_HWW;
2469 }
2470 }
2471}
2472
2473muggHWW2l2v::muggHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
2474: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2475{
2476 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2477 throw std::runtime_error("muggHWW2l2v called with a class whose parent is not NPbase");
2478}
2479
2481{
2482 if ((this->getModel()).isModelLinearized()) {
2483 return ( -1.0 + (myNPbase->muggH(sqrt_s)) + (myNPbase->BrH2l2vRatio()));
2484 } else {
2485 return myNPbase->muggHWW2l2v(sqrt_s);
2486 }
2487}
2488
2489muVBFHWW2l2v::muVBFHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
2490: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2491{
2492 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2493 throw std::runtime_error("muVBFHWW2l2v called with a class whose parent is not NPbase");
2494}
2495
2497{
2498 if ((this->getModel()).isModelLinearized()) {
2499 return ( -1.0 + (myNPbase->muVBF(sqrt_s)) + (myNPbase->BrH2l2vRatio()));
2500 } else {
2501 return myNPbase->muVBFHWW2l2v(sqrt_s);
2502 }
2503}
2504
2505muZHWW2l2v::muZHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
2506: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2507{
2508 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2509 throw std::runtime_error("muZHWW2l2v called with a class whose parent is not NPbase");
2510}
2511
2513{
2514 if ((this->getModel()).isModelLinearized()) {
2515 return ( -1.0 + (myNPbase->muZH(sqrt_s)) + (myNPbase->BrH2l2vRatio()));
2516 } else {
2517 return myNPbase->muZHWW2l2v(sqrt_s);
2518 }
2519}
2520
2521muWHWW2l2v::muWHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
2522: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2523{
2524 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2525 throw std::runtime_error("muWHWW2l2v called with a class whose parent is not NPbase");
2526}
2527
2529{
2530 if ((this->getModel()).isModelLinearized()) {
2531 return ( -1.0 + (myNPbase->muWH(sqrt_s)) + (myNPbase->BrH2l2vRatio()));
2532 } else {
2533 return myNPbase->muWHWW2l2v(sqrt_s);
2534 }
2535}
2536
2537muVHWW2l2v::muVHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
2538: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2539{
2540 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2541 throw std::runtime_error("muVHWW2l2v called with a class whose parent is not NPbase");
2542}
2543
2545{
2546 if ((this->getModel()).isModelLinearized()) {
2547 return ( -1.0 + (myNPbase->muVH(sqrt_s)) + (myNPbase->BrH2l2vRatio()));
2548 } else {
2549 return myNPbase->muVHWW2l2v(sqrt_s);
2550 }
2551}
2552
2553muttHWW2l2v::muttHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
2554: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2555{
2556 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2557 throw std::runtime_error("muttHWW2l2v called with a class whose parent is not NPbase");
2558}
2559
2561{
2562 if ((this->getModel()).isModelLinearized()) {
2563 return ( -1.0 + (myNPbase->muttH(sqrt_s)) + (myNPbase->BrH2l2vRatio()));
2564 } else {
2565 return myNPbase->muttHWW2l2v(sqrt_s);
2566 }
2567}
2568
2569muttHVV::muttHVV(const StandardModel& SM_i, const double sqrt_s_i)
2570: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2571{
2572 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2573 throw std::runtime_error("muttHVV called with a class whose parent is not NPbase");
2574}
2575
2577{
2578 if ((this->getModel()).isModelLinearized()) {
2579 return ( -1.0 + (myNPbase->muttH(sqrt_s)) + (myNPbase->BrHVVRatio()));
2580 } else {
2581 return (myNPbase->muttH(sqrt_s)) * (myNPbase->BrHVVRatio());
2582 }
2583}
2584
2585muggHmumu::muggHmumu(const StandardModel& SM_i, const double sqrt_s_i)
2586: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2587{
2588 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2589 throw std::runtime_error("muggHmumu called with a class whose parent is not NPbase");
2590}
2591
2593{
2594 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2595 //return ( -1.0 + (myNPbase->muggH(sqrt_s)) + (myNPbase->BrHmumuRatio()));
2596 //AG: Most general expression including quadratic corrections.
2597 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2598 double muProd1 = myNPbase->delta_muggH_1(sqrt_s);
2599 double muProd2 = myNPbase->delta_muggH_2(sqrt_s);
2600 double dGammaR1 = myNPbase->deltaGammaHmumuRatio1();
2601 double dGammaR2 = myNPbase->deltaGammaHmumuRatio2();
2602
2603 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2604 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2605 double Br1 = dGammaR1-dGammaRTot1;
2606 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2607
2608 double mu;
2609
2610 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2611
2612 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2613
2614 return mu;
2615
2616 } else {
2617 return myNPbase->muggHmumu(sqrt_s);
2618 }
2619}
2620
2621muVBFHmumu::muVBFHmumu(const StandardModel& SM_i, const double sqrt_s_i)
2622: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2623{
2624 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2625 throw std::runtime_error("muVBFHmumu called with a class whose parent is not NPbase");
2626}
2627
2629{
2630 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2631 //return ( -1.0 + (myNPbase->muVBF(sqrt_s)) + (myNPbase->BrHmumuRatio()));
2632 //AG: Most general expression including quadratic corrections.
2633 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2634 double muProd1 = myNPbase->delta_muVBF_1(sqrt_s);
2635 double muProd2 = myNPbase->delta_muVBF_2(sqrt_s);
2636 double dGammaR1 = myNPbase->deltaGammaHmumuRatio1();
2637 double dGammaR2 = myNPbase->deltaGammaHmumuRatio2();
2638
2639 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2640 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2641 double Br1 = dGammaR1-dGammaRTot1;
2642 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2643
2644 double mu;
2645
2646 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2647
2648 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2649
2650 return mu;
2651
2652 } else {
2653 return myNPbase->muVBFHmumu(sqrt_s);
2654 }
2655}
2656
2657muZHmumu::muZHmumu(const StandardModel& SM_i, const double sqrt_s_i)
2658: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2659{
2660 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2661 throw std::runtime_error("muZHmumu called with a class whose parent is not NPbase");
2662}
2663
2665{
2666 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2667 //AG: Most general expression including quadratic corrections.
2668 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2669 double muProd1 = myNPbase->delta_muZH_1(sqrt_s);
2670 double muProd2 = myNPbase->delta_muZH_2(sqrt_s);
2671 double dGammaR1 = myNPbase->deltaGammaHmumuRatio1();
2672 double dGammaR2 = myNPbase->deltaGammaHmumuRatio2();
2673
2674 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2675 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2676 double Br1 = dGammaR1-dGammaRTot1;
2677 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2678
2679 double mu;
2680
2681 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2682
2683 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2684
2685 return mu;
2686
2687 } else {
2688 return myNPbase->muZHmumu(sqrt_s);
2689 }
2690}
2691
2692muWHmumu::muWHmumu(const StandardModel& SM_i, const double sqrt_s_i)
2693: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2694{
2695 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2696 throw std::runtime_error("muWHmumu called with a class whose parent is not NPbase");
2697}
2698
2700{
2701 if ((this->getModel()).isModelLinearized()) {
2702 return ( -1.0 + (myNPbase->muWH(sqrt_s)) + (myNPbase->BrHmumuRatio()));
2703 } else {
2704 return myNPbase->muWHmumu(sqrt_s);
2705 }
2706}
2707
2708muVHmumu::muVHmumu(const StandardModel& SM_i, const double sqrt_s_i)
2709: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2710{
2711 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2712 throw std::runtime_error("muVHmumu called with a class whose parent is not NPbase");
2713}
2714
2716{
2717
2718 //VM:Note that these values are valid for 13 TeV, they are not general
2719 //We should access the SM function that has all the values (for the
2720 //different energies). The values are slightly different, we should
2721 //check this.
2722 //Ref: https://www.hepdata.net/record/ins2104706 Figure2a (symmetrized)
2723 double xsSM_WH = 1.21539;
2724 double xsSM_ZH = 0.795910;
2725 //double xsSM_WH = myNPbase->computeSigmaWH(sqrt_s);
2726 //double xsSM_ZH = myNPbase->computeSigmaZH(sqrt_s);
2727 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2728 //return ( -1.0 + (myNPbase->muVH(sqrt_s)) + (myNPbase->BrHmumuRatio()));
2729 //AG: Most general expression including quadratic corrections.
2730 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2731 double muProd1 = ( xsSM_ZH*(myNPbase->delta_muZH_1(sqrt_s)) + xsSM_WH*(myNPbase->delta_muWH_1(sqrt_s)) )/(xsSM_ZH+xsSM_WH);
2732 double muProd2 = ( xsSM_ZH*(myNPbase->delta_muZH_2(sqrt_s)) + xsSM_WH*(myNPbase->delta_muWH_2(sqrt_s)) )/(xsSM_ZH+xsSM_WH);
2733 double dGammaR1 = myNPbase->deltaGammaHmumuRatio1();
2734 double dGammaR2 = myNPbase->deltaGammaHmumuRatio2();
2735
2736 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2737 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2738 double Br1 = dGammaR1-dGammaRTot1;
2739 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2740
2741 double mu;
2742
2743 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2744
2745 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2746
2747 return mu;
2748
2749 } else {
2750 //return myNPbase->muVHmumu(sqrt_s);
2751 //VM: Just in case someone wants to add directly the production*decay
2752 //(which is the observable we fit at the end)
2753 double NPmuVHmumu = myNPbase->muVHmumu(sqrt_s);
2754 if(NPmuVHmumu==1.0){
2755 return ( xsSM_ZH*(myNPbase->muZH(sqrt_s)) + xsSM_WH*(myNPbase->muWH(sqrt_s)) )/(xsSM_ZH+xsSM_WH) * (myNPbase->BrHmumuRatio());
2756 } else {
2757 return NPmuVHmumu;
2758 }
2759
2760 }
2761}
2762
2763muttHmumu::muttHmumu(const StandardModel& SM_i, const double sqrt_s_i)
2764: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2765{
2766 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2767 throw std::runtime_error("muttHmumu called with a class whose parent is not NPbase");
2768}
2769
2771{
2772 if ((this->getModel()).isModelLinearized()) {
2773 return ( -1.0 + (myNPbase->muttH(sqrt_s)) + (myNPbase->BrHmumuRatio()));
2774 } else {
2775 return myNPbase->muttHmumu(sqrt_s);
2776 }
2777}
2778
2779muggHpttHptHpbbH_Hmumu::muggHpttHptHpbbH_Hmumu(const StandardModel& SM_i, const double sqrt_s_i) //AG:added
2780: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2781{
2782 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2783 throw std::runtime_error("muggHpttHptHpbbH_Hmumu called with a class whose parent is not NPbase");
2784}
2785
2787{
2788 //VM:Note that these values are valid for 13 TeV, they are not general
2789 //We should access the SM function that has all the values (for the
2790 //different energies). The values are slightly different, we should
2791 //check this. Furthermore, the bbH is not included. In the SM this is
2792 //very suppressed (and it's probably also the case in the SMEFT) but
2793 //in some NP models it may not be the case.Unfortunately, bbH is not
2794 //obtained in the SMEFT, we could just set delta_mubbH to zero in the
2795 //SMEFT and add here the general expression.
2796 //Ref: https://www.hepdata.net/record/ins2104706 Figure2a (symmetrized)
2797 double xsSM_ggHbbH = 44.745;
2798 double xsSM_ttH = 0.4998;
2799 double xsSM_tH = 0.084769;
2800 //double xsSM_ggH = myNPbase->computeSigmaggH(sqrt_s);
2801 //double xsSM_ttH = myNPbase->computeSigmattH(sqrt_s);
2802 //double xsSM_tH = myNPbase->computeSigmatH(sqrt_s);
2803 //double xsSM_bbH = myNPbase->computeSigmabbH(sqrt_s);
2804
2805
2806
2807 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2808 //AG: Most general expression including quadratic corrections.
2809 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2810 double muProd1 = ( xsSM_ggHbbH*(myNPbase->delta_muggH_1(sqrt_s)) + xsSM_ttH*(myNPbase->delta_muttH_1(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_1(sqrt_s)) )/(xsSM_ggHbbH+xsSM_ttH+xsSM_tH) ;
2811 double muProd2 = ( xsSM_ggHbbH*(myNPbase->delta_muggH_2(sqrt_s)) + xsSM_ttH*(myNPbase->delta_muttH_2(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_2(sqrt_s)) )/(xsSM_ggHbbH+xsSM_ttH+xsSM_tH) ;
2812 double dGammaR1 = myNPbase->deltaGammaHmumuRatio1();
2813 double dGammaR2 = myNPbase->deltaGammaHmumuRatio2();
2814
2815 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2816 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2817 double Br1 = dGammaR1-dGammaRTot1;
2818 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2819
2820 double mu;
2821
2822 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2823
2824 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2825
2826 return mu;
2827
2828 } else {
2829
2830 //VM: Just in case someone wants to add directly the production*decay
2831 //(which is the observable we fit at the end). Furthermore, the Hbb
2832 //is not added in the original formula, fine for the SM (probably also
2833 //for the SMEFT) but not for all NP models.
2834 double NPmuggHpttHptHpbbH_Hmumu = myNPbase->muggHpttHptHpbbH_Hmumu(sqrt_s);
2835 if(NPmuggHpttHptHpbbH_Hmumu==1.0){
2836 return ( (xsSM_ggHbbH*(myNPbase->muggH(sqrt_s))+xsSM_ttH*(myNPbase->muttH(sqrt_s))+xsSM_tH*(myNPbase->mutH(sqrt_s))) / (xsSM_ggHbbH+xsSM_ttH+xsSM_tH) )*(myNPbase->BrHmumuRatio()) ;
2837 } else {
2838 return NPmuggHpttHptHpbbH_Hmumu;
2839 }
2840 }
2841}
2842
2843muVBFpVH_Hmumu::muVBFpVH_Hmumu(const StandardModel& SM_i, const double sqrt_s_i) //AG:added
2844: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2845{
2846 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2847 throw std::runtime_error("muVBFpVH_Hmumu called with a class whose parent is not NPbase");
2848}
2849
2851{
2852
2853 //VM:Note that these values are valid for 13 TeV, they are not general
2854 //We should access the SM function that has all the values (for the
2855 //different energies). The values are slightly different, we should
2856 //check this.
2857 //Ref: https://www.hepdata.net/record/ins2104706 Figure2a (symmetrized)
2858 double xsSM_VBF = 3.49948;
2859 double xsSM_WH = 1.21539;
2860 double xsSM_ZH = 0.795910;
2861 //double xsSM_VBF = myNPbase->computeSigmaVBF(sqrt_s);
2862 //double xsSM_WH = myNPbase->computeSigmaWH(sqrt_s);
2863 //double xsSM_ZH = myNPbase->computeSigmaZH(sqrt_s);
2864 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2865 //AG: Most general expression including quadratic corrections.
2866 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2867 double muProd1 = ( xsSM_VBF*(myNPbase->delta_muVBF_1(sqrt_s)) + xsSM_WH*(myNPbase->delta_muWH_1(sqrt_s)) + xsSM_ZH*(myNPbase->delta_muZH_1(sqrt_s)) )/(xsSM_VBF+xsSM_WH+xsSM_ZH);
2868 double muProd2 = ( xsSM_VBF*(myNPbase->delta_muVBF_2(sqrt_s)) + xsSM_WH*(myNPbase->delta_muWH_2(sqrt_s)) + xsSM_ZH*(myNPbase->delta_muZH_2(sqrt_s)) )/(xsSM_VBF+xsSM_WH+xsSM_ZH);
2869 double dGammaR1 = myNPbase->deltaGammaHmumuRatio1();
2870 double dGammaR2 = myNPbase->deltaGammaHmumuRatio2();
2871
2872 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2873 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2874 double Br1 = dGammaR1-dGammaRTot1;
2875 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2876
2877 double mu;
2878
2879 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2880
2881 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2882
2883 return mu;
2884
2885 } else {
2886
2887 //VM: Just in case someone wants to add directly the production*decay
2888 //(which is the observable we fit at the end).
2889 double NPmuVBFpVH_Hmumu = myNPbase->muVBFpVH_Hmumu(sqrt_s);
2890 if(NPmuVBFpVH_Hmumu==1.0){
2891 return ( (xsSM_VBF*(myNPbase->muVBF(sqrt_s))+xsSM_WH*(myNPbase->muWH(sqrt_s))+xsSM_ZH*(myNPbase->muZH(sqrt_s))) / (xsSM_VBF+xsSM_WH+xsSM_ZH) )*(myNPbase->BrHmumuRatio()) ;
2892 } else {
2893 return NPmuVBFpVH_Hmumu;
2894 }
2895 }
2896}
2897
2898muggHtautau::muggHtautau(const StandardModel& SM_i, const double sqrt_s_i)
2899: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2900{
2901 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2902 throw std::runtime_error("muggHtautau called with a class whose parent is not NPbase");
2903}
2904
2906{
2907 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2908 //AG: Most general expression including quadratic corrections.
2909 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2910 //return ( -1.0 + (myNPbase->muVBF(sqrt_s)) + (myNPbase->BrHtautauRatio()));
2911 double muProd1 = myNPbase->delta_muggH_1(sqrt_s);
2912 double muProd2 = myNPbase->delta_muggH_2(sqrt_s);
2913 double dGammaR1 = myNPbase->deltaGammaHtautauRatio1();
2914 double dGammaR2 = myNPbase->deltaGammaHtautauRatio2();
2915
2916 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2917 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2918 double Br1 = dGammaR1-dGammaRTot1;
2919 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2920
2921 double mu;
2922
2923 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2924
2925 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2926
2927 return mu;
2928
2929 } else {
2930 return myNPbase->muggHtautau(sqrt_s);
2931 }
2932}
2933
2934muVBFHtautau::muVBFHtautau(const StandardModel& SM_i, const double sqrt_s_i)
2935: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2936{
2937 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2938 throw std::runtime_error("muVBFHtautau called with a class whose parent is not NPbase");
2939}
2940
2942{
2943 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2944 //AG: Most general expression including quadratic corrections.
2945 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
2946 //return ( -1.0 + (myNPbase->muVBF(sqrt_s)) + (myNPbase->BrHtautauRatio()));
2947 double muProd1 = myNPbase->delta_muVBF_1(sqrt_s);
2948 double muProd2 = myNPbase->delta_muVBF_2(sqrt_s);
2949 double dGammaR1 = myNPbase->deltaGammaHtautauRatio1();
2950 double dGammaR2 = myNPbase->deltaGammaHtautauRatio2();
2951
2952 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
2953 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
2954 double Br1 = dGammaR1-dGammaRTot1;
2955 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2956
2957 double mu;
2958
2959 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2960
2961 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
2962
2963 return mu;
2964
2965 } else {
2966 return myNPbase->muVBFHtautau(sqrt_s);
2967 }
2968}
2969
2970
2971
2972muVBFpVHtautau::muVBFpVHtautau(const StandardModel& SM_i, const double sqrt_s_i)
2973: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2974{
2975 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2976 throw std::runtime_error("muVBFpVHtautau called with a class whose parent is not NPbase");
2977}
2978
2980{
2981 if ((this->getModel()).isModelLinearized()) {
2982 return ( -1.0 + (myNPbase->muVBFpVH(sqrt_s)) + (myNPbase->BrHtautauRatio()));
2983 } else {
2985 }
2986}
2987
2988
2989muZHtautau::muZHtautau(const StandardModel& SM_i, const double sqrt_s_i)
2990: ThObservable(SM_i), sqrt_s(sqrt_s_i)
2991{
2992 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
2993 throw std::runtime_error("muZHtautau called with a class whose parent is not NPbase");
2994}
2995
2996double muZHtautau::computeThValue() //AG:modified
2997{
2998 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
2999 //return ( -1.0 + (myNPbase->muZH(sqrt_s)) + (myNPbase->BrHtautauRatio()));
3000 //AG: Most general expression including quadratic corrections.
3001 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
3002 //return ( -1.0 + (myNPbase->muVBF(sqrt_s)) + (myNPbase->BrHtautauRatio()));
3003 double muProd1 = myNPbase->delta_muZH_1(sqrt_s);
3004 double muProd2 = myNPbase->delta_muZH_2(sqrt_s);
3005 double dGammaR1 = myNPbase->deltaGammaHtautauRatio1();
3006 double dGammaR2 = myNPbase->deltaGammaHtautauRatio2();
3007
3008 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
3009 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
3010 double Br1 = dGammaR1-dGammaRTot1;
3011 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
3012
3013 double mu;
3014
3015 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
3016
3017 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
3018
3019 return mu;
3020
3021 } else {
3022 return myNPbase->muZHtautau(sqrt_s);
3023 }
3024}
3025
3026muWHtautau::muWHtautau(const StandardModel& SM_i, const double sqrt_s_i)
3027: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3028{
3029 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3030 throw std::runtime_error("muWHtautau called with a class whose parent is not NPbase");
3031}
3032
3034{
3035 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
3036 //return ( -1.0 + (myNPbase->muWH(sqrt_s)) + (myNPbase->BrHtautauRatio()));
3037 //AG: Most general expression including quadratic corrections.
3038 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
3039 double muProd1 = myNPbase->delta_muWH_1(sqrt_s);
3040 double muProd2 = myNPbase->delta_muWH_2(sqrt_s);
3041 double dGammaR1 = myNPbase->deltaGammaHtautauRatio1();
3042 double dGammaR2 = myNPbase->deltaGammaHtautauRatio2();
3043
3044 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
3045 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
3046 double Br1 = dGammaR1-dGammaRTot1;
3047 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
3048
3049 /*std::cout << "muProd1="<<muProd1<<std::endl;
3050 std::cout << "muProd2="<<muProd2<<std::endl;
3051 std::cout << "dGammaR1="<<dGammaR1<<std::endl;
3052 std::cout << "dGammaR2="<<dGammaR2<<std::endl;
3053 std::cout << "dGammaRTot1="<<dGammaRTot1<<std::endl;
3054 std::cout << "dGammaRTot2="<<dGammaRTot2<<std::endl;
3055
3056 std::cout<<myNPbase->muWH(sqrt_s)<<std::endl;
3057 std::cout<<myNPbase->muWH(sqrt_s)<<std::endl;*/
3058
3059 double mu;
3060
3061 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
3062
3063 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
3064
3065 return mu;
3066
3067 } else {
3068 return myNPbase->muWHtautau(sqrt_s);
3069 }
3070}
3071
3072muVHtautau::muVHtautau(const StandardModel& SM_i, const double sqrt_s_i)
3073: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3074{
3075 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3076 throw std::runtime_error("muVHtautau called with a class whose parent is not NPbase");
3077}
3078
3080{
3081 //VM:Note that these values are valid for 13 TeV, they are not general
3082 //We should access the SM function that has all the values (for the
3083 //different energies). The values are slightly different, we should
3084 //check this.
3085 //Ref: https://www.hepdata.net/record/ins2104706 Figure2a (symmetrized)
3086 double xsSM_WH = 1.21539;
3087 double xsSM_ZH = 0.795910;
3088 //double xsSM_WH = myNPbase->computeSigmaWH(sqrt_s);
3089 //double xsSM_ZH = myNPbase->computeSigmaZH(sqrt_s);
3090 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
3091 //AG: Most general expression including quadratic corrections.
3092 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
3093 //return ( -1.0 + (myNPbase->muVH(sqrt_s)) + (myNPbase->BrHtautauRatio()));
3094 double muProd1 = ( xsSM_ZH*(myNPbase->delta_muZH_1(sqrt_s)) + xsSM_WH*(myNPbase->delta_muWH_1(sqrt_s)) )/(xsSM_ZH+xsSM_WH);
3095 double muProd2 = ( xsSM_ZH*(myNPbase->delta_muZH_2(sqrt_s)) + xsSM_WH*(myNPbase->delta_muWH_2(sqrt_s)) )/(xsSM_ZH+xsSM_WH);
3096 double dGammaR1 = myNPbase->deltaGammaHtautauRatio1();
3097 double dGammaR2 = myNPbase->deltaGammaHtautauRatio2();
3098
3099 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
3100 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
3101 double Br1 = dGammaR1-dGammaRTot1;
3102 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
3103
3104 double mu;
3105
3106 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
3107
3108 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
3109
3110 return mu;
3111
3112 } else {
3113 //return myNPbase->muVHtautau(sqrt_s);
3114
3115 //VM: Just in case someone wants to add directly the production*decay
3116 //(which is the observable we fit at the end)
3117 double NPmuVHtautau = myNPbase->muVHtautau(sqrt_s);
3118 if(NPmuVHtautau==1.0){
3119 return ( xsSM_ZH*(myNPbase->muZH(sqrt_s)) + xsSM_WH*(myNPbase->muWH(sqrt_s)) )/(xsSM_ZH+xsSM_WH) * (myNPbase->BrHtautauRatio());
3120 } else {
3121 return NPmuVHtautau;
3122 }
3123 }
3124}
3125
3126muttHtautau::muttHtautau(const StandardModel& SM_i, const double sqrt_s_i)
3127: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3128{
3129 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3130 throw std::runtime_error("muttHtautau called with a class whose parent is not NPbase");
3131}
3132
3134{
3135 if ((this->getModel()).isModelLinearized()) {
3136 return ( -1.0 + (myNPbase->muttH(sqrt_s)) + (myNPbase->BrHtautauRatio()));
3137 } else {
3138 return myNPbase->muttHtautau(sqrt_s);
3139 }
3140}
3141
3142muttHptH_Htautau::muttHptH_Htautau(const StandardModel& SM_i, const double sqrt_s_i) //AG:added
3143: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3144{
3145 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3146 throw std::runtime_error("muttHptH_Htautau called with a class whose parent is not NPbase");
3147}
3148
3150{
3151 //VM:Note that these values are valid for 13 TeV, they are not general
3152 //We should access the SM function that has all the values (for the
3153 //different energies). The values are slightly different, we should
3154 //check this.
3155 //Ref: https://www.hepdata.net/record/ins2104706 Figure2a (symmetrized)
3156 double xsSM_ttH = 0.499873;
3157 double xsSM_tH = 0.0821;
3158 //double xsSM_ttH = myNPbase->computeSigmattH(sqrt_s);
3159 //double xsSM_tH = myNPbase->computeSigmatHq(sqrt_s);
3160 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
3161 //AG: Most general expression including quadratic corrections.
3162 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
3163 double muProd1 = ( xsSM_ttH*(myNPbase->delta_muttH_1(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_1(sqrt_s)) )/(xsSM_ttH+xsSM_tH);
3164 double muProd2 = ( xsSM_ttH*(myNPbase->delta_muttH_2(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_2(sqrt_s)) )/(xsSM_ttH+xsSM_tH);
3165 double dGammaR1 = myNPbase->deltaGammaHtautauRatio1();
3166 double dGammaR2 = myNPbase->deltaGammaHtautauRatio2();
3167
3168 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
3169 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
3170 double Br1 = dGammaR1-dGammaRTot1;
3171 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
3172
3173 double mu;
3174
3175 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
3176
3177 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
3178
3179 return mu;
3180
3181 } else {
3182
3183 //VM: Just in case someone wants to add directly the production*decay
3184 //(which is the observable we fit at the end)
3185 double NPmuttHptH_Htautau = myNPbase->muttHptH_Htautau(sqrt_s);
3186 if(NPmuttHptH_Htautau==1.0){
3187 return ( xsSM_ttH*(myNPbase->muttH(sqrt_s)) + xsSM_tH*(myNPbase->mutH(sqrt_s)) )/(xsSM_ttH+xsSM_tH) * (myNPbase->BrHtautauRatio()) ;
3188 } else {
3189 return NPmuttHptH_Htautau;
3190 }
3191
3192 }
3193}
3194
3195muggHpbbH_Htautau::muggHpbbH_Htautau(const StandardModel& SM_i, const double sqrt_s_i) //AG:added
3196: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3197{
3198 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3199 throw std::runtime_error("muggHpbbH_Htautau called with a class whose parent is not NPbase");
3200}
3201
3203{
3204 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
3205 //AG: Most general expression including quadratic corrections.
3206 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
3207 //return ( 1.0 + (myNPbase->muggH(sqrt_s)-1.) + (myNPbase->BrHtautauRatio()-1.));
3208 double muProd1 = myNPbase->delta_muggH_1(sqrt_s);
3209 double muProd2 = myNPbase->delta_muggH_2(sqrt_s);
3210 double dGammaR1 = myNPbase->deltaGammaHtautauRatio1();
3211 double dGammaR2 = myNPbase->deltaGammaHtautauRatio2();
3212
3213 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
3214 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
3215 double Br1 = dGammaR1-dGammaRTot1;
3216 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
3217
3218 double mu;
3219
3220 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
3221
3222 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
3223
3224 return mu;
3225
3226 } else {
3227
3228 //VM: Just in case someone wants to add directly the production*decay
3229 //(which is the observable we fit at the end)
3230 //Also, the bbH is missing here, I'll leave it as it was for the
3231 //moment (since bbH is really suppressed in the SM).
3232 double NPmuggHpbbH_Htautau = myNPbase->muggHpbbH_Htautau(sqrt_s);
3233 if (NPmuggHpbbH_Htautau == 1.0){
3234 return (myNPbase->muggHtautau(sqrt_s));
3235 } else{
3236 return NPmuggHpbbH_Htautau;
3237 }
3238 }
3239}
3240
3241muggHbb::muggHbb(const StandardModel& SM_i, const double sqrt_s_i)
3242: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3243{
3244 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3245 throw std::runtime_error("muggHbb called with a class whose parent is not NPbase");
3246}
3247
3249{
3250 if ((this->getModel()).isModelLinearized()) {
3251 //return ( -1.0 + (myNPbase->muggH(sqrt_s)) + (myNPbase->BrHbbRatio()));
3252 //AG: Most general expression including quadratic corrections.
3253 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
3254 double muProd1 = myNPbase->delta_muggH_1(sqrt_s);
3255 double muProd2 = myNPbase->delta_muggH_2(sqrt_s);
3256 double dGammaR1 = myNPbase->deltaGammaHbbRatio1();
3257 double dGammaR2 = myNPbase->deltaGammaHbbRatio2();
3258
3259 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
3260 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
3261 double Br1 = dGammaR1-dGammaRTot1;
3262 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
3263
3264 double mu;
3265
3266 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
3267
3268 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
3269
3270 return mu;
3271
3272 } else {
3273 return myNPbase->muggHbb(sqrt_s);
3274 }
3275}
3276
3277muVBFHbb::muVBFHbb(const StandardModel& SM_i, const double sqrt_s_i)
3278: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3279{
3280 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3281 throw std::runtime_error("muVBFHbb called with a class whose parent is not NPbase");
3282}
3283
3285{
3286 if ((this->getModel()).isModelLinearized()) {
3287 return ( -1.0 + (myNPbase->muVBF(sqrt_s)) + (myNPbase->BrHbbRatio()));
3288 } else {
3289 return myNPbase->muVBFHbb(sqrt_s);
3290 }
3291}
3292
3293muZHbb::muZHbb(const StandardModel& SM_i, const double sqrt_s_i)
3294: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3295{
3296 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3297 throw std::runtime_error("muZHbb called with a class whose parent is not NPbase");
3298}
3299
3301{
3302 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
3303 //AG: Most general expression including quadratic corrections.
3304 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
3305 //return ( -1.0 + (myNPbase->muZH(sqrt_s)) + (myNPbase->BrHbbRatio()));
3306 double muProd1 = myNPbase->delta_muZH_1(sqrt_s);
3307 double muProd2 = myNPbase->delta_muZH_2(sqrt_s);
3308 double dGammaR1 = myNPbase->deltaGammaHbbRatio1();
3309 double dGammaR2 = myNPbase->deltaGammaHbbRatio2();
3310
3311 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
3312 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
3313 double Br1 = dGammaR1-dGammaRTot1;
3314 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
3315
3316 double mu;
3317
3318 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
3319
3320 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
3321
3322 return mu;
3323
3324 } else {
3325 return myNPbase->muZHbb(sqrt_s);
3326 }
3327}
3328
3329muWHbb::muWHbb(const StandardModel& SM_i, const double sqrt_s_i)
3330: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3331{
3332 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3333 throw std::runtime_error("muWHbb called with a class whose parent is not NPbase");
3334}
3335
3337{
3338 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
3339 //AG: Most general expression including quadratic corrections.
3340 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
3341 //return ( -1.0 + (myNPbase->muWH(sqrt_s)) + (myNPbase->BrHbbRatio()));
3342 double muProd1 = myNPbase->delta_muWH_1(sqrt_s);
3343 double muProd2 = myNPbase->delta_muWH_2(sqrt_s);
3344 double dGammaR1 = myNPbase->deltaGammaHbbRatio1();
3345 double dGammaR2 = myNPbase->deltaGammaHbbRatio2();
3346
3347 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
3348 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
3349 double Br1 = dGammaR1-dGammaRTot1;
3350 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
3351
3352 double mu;
3353
3354 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
3355
3356 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
3357
3358 return mu;
3359
3360 } else {
3361 return myNPbase->muWHbb(sqrt_s);
3362 }
3363}
3364
3365muVHbb::muVHbb(const StandardModel& SM_i, const double sqrt_s_i)
3366: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3367{
3368 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3369 throw std::runtime_error("muVHbb called with a class whose parent is not NPbase");
3370}
3371
3373{
3374 if ((this->getModel()).isModelLinearized()) {
3375 return ( -1.0 + (myNPbase->muVH(sqrt_s)) + (myNPbase->BrHbbRatio()));
3376 } else {
3377 return myNPbase->muVHbb(sqrt_s);
3378 }
3379}
3380
3381muttHbb::muttHbb(const StandardModel& SM_i, const double sqrt_s_i)
3382: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3383{
3384 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3385 throw std::runtime_error("muttHbb called with a class whose parent is not NPbase");
3386}
3387
3389{
3390 if ((this->getModel()).isModelLinearized()) {
3391 return ( -1.0 + (myNPbase->muttH(sqrt_s)) + (myNPbase->BrHbbRatio()));
3392 } else {
3393 return myNPbase->muttHbb(sqrt_s);
3394 }
3395}
3396
3397muttHptH_Hbb::muttHptH_Hbb(const StandardModel& SM_i, const double sqrt_s_i) //AG:added
3398: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3399{
3400 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3401 throw std::runtime_error("muttHptH_Hbb called with a class whose parent is not NPbase");
3402}
3403
3405{
3406 //VM:Note that these values are valid for 13 TeV, they are not general
3407 //We should access the SM function that has all the values (for the
3408 //different energies). The values are slightly different, we should
3409 //check this.
3410 //Ref: https://www.hepdata.net/record/ins2104706 Figure2a (symmetrized)
3411 double xsSM_ttH = 0.499873;
3412 double xsSM_tH = 0.0821;
3413 //double xsSM_ttH = myNPbase->computeSigmattH(sqrt_s);
3414 //double xsSM_tH = myNPbase->computeSigmatHq(sqrt_s);
3415 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
3416 //AG: Most general expression including quadratic corrections.
3417 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
3418 double muProd1 = ( xsSM_ttH*(myNPbase->delta_muttH_1(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_1(sqrt_s)) )/(xsSM_ttH+xsSM_tH);
3419 double muProd2 = ( xsSM_ttH*(myNPbase->delta_muttH_2(sqrt_s)) + xsSM_tH*(myNPbase->delta_mutH_2(sqrt_s)) )/(xsSM_ttH+xsSM_tH);
3420 double dGammaR1 = myNPbase->deltaGammaHbbRatio1();
3421 double dGammaR2 = myNPbase->deltaGammaHbbRatio2();
3422
3423 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
3424 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
3425 double Br1 = dGammaR1-dGammaRTot1;
3426 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
3427
3428 double mu;
3429
3430 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
3431
3432 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
3433
3434 return mu;
3435
3436 } else {
3437
3438
3439 //VM: Just in case someone wants to add directly the production*decay
3440 //(which is the observable we fit at the end)
3441 double NPmuttHptH_Hbb = myNPbase->muttHptH_Hbb(sqrt_s);
3442 if(NPmuttHptH_Hbb==1.0){
3443 return ( xsSM_ttH*(myNPbase->muttH(sqrt_s)) + xsSM_tH*(myNPbase->mutH(sqrt_s)) )/(xsSM_ttH+xsSM_tH) * (myNPbase->BrHbbRatio()) ;
3444 } else {
3445 return NPmuttHptH_Hbb;
3446 }
3447 }
3448}
3449
3450muggHpVBFpbbH_Hbb::muggHpVBFpbbH_Hbb(const StandardModel& SM_i, const double sqrt_s_i) //AG:added
3451: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3452{
3453 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3454 throw std::runtime_error("muggHpVBFpbbH_Hbb called with a class whose parent is not NPbase");
3455}
3456
3458{
3459 //VM:Note that these values are valid for 13 TeV, they are not general
3460 //We should access the SM function that has all the values (for the
3461 //different energies). The values are slightly different, we should
3462 //check this. Furthermore, the bbH is not included. In the SM this is
3463 //very suppressed (and it's probably also the case in the SMEFT) but
3464 //in some NP models it may not be the case.Unfortunately, bbH is not
3465 //obtained in the SMEFT, we could just set delta_mubbH to zero in the
3466 //SMEFT and add here the general expression.
3467 //Ref: https://www.hepdata.net/record/ins2104706 Figure2a (symmetrized)
3468 double xsSM_ggHbbH = 44.745;
3469 double xsSM_VBF = 3.49948;
3470 //double xsSM_ggH = myNPbase->computeSigmaggH(sqrt_s);
3471 //double xsSM_VBF = myNPbase->computeSigmaVBF(sqrt_s);
3472 //double xsSM_bbH = myNPbase->computeSigmabbH(sqrt_s);
3473 if ((this->getModel()).isModelLinearized() || (this->getModel()).isModelNPquadratic()) {
3474 //AG: Most general expression including quadratic corrections.
3475 // If FlagQuadraticTerms=false, the quadratic pieces become 0 in NPSMEFTd6General
3476 double muProd1 = ( xsSM_ggHbbH*(myNPbase->delta_muggH_1(sqrt_s)) + xsSM_VBF*(myNPbase->delta_muVBF_1(sqrt_s)) )/(xsSM_ggHbbH+xsSM_VBF);
3477 double muProd2 = ( xsSM_ggHbbH*(myNPbase->delta_muggH_2(sqrt_s)) + xsSM_VBF*(myNPbase->delta_muVBF_2(sqrt_s)) )/(xsSM_ggHbbH+xsSM_VBF);
3478 double dGammaR1 = myNPbase->deltaGammaHbbRatio1();
3479 double dGammaR2 = myNPbase->deltaGammaHbbRatio2();
3480
3481 double dGammaRTot1 = myNPbase->deltaGammaTotalRatio1();
3482 double dGammaRTot2 = myNPbase->deltaGammaTotalRatio2();
3483 double Br1 = dGammaR1-dGammaRTot1;
3484 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
3485
3486 double mu;
3487
3488 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
3489
3490 if (mu < 0) return std::numeric_limits<double>::quiet_NaN();
3491
3492 return mu;
3493
3494 } else {
3495
3496
3497 //VM: Just in case someone wants to add directly the production*decay
3498 //(which is the observable we fit at the end). Furthermore, the Hbb
3499 //is not added in the original formula, fine for the SM (probably also
3500 //for the SMEFT) but not for all NP models.
3501 double NPmuggHpVBFpbbH_Hbb = myNPbase->muggHpVBFpbbH_Hbb(sqrt_s);
3502 if(NPmuggHpVBFpbbH_Hbb==1.0){
3503 return ( xsSM_ggHbbH*(myNPbase->muggH(sqrt_s)) + xsSM_VBF*(myNPbase->muVBF(sqrt_s)) )/(xsSM_ggHbbH+xsSM_VBF) * (myNPbase->BrHbbRatio()) ;
3504 } else {
3505 return NPmuggHpVBFpbbH_Hbb;
3506 }
3507 }
3508}
3509
3510
3511
3512muVHcc::muVHcc(const StandardModel& SM_i, const double sqrt_s_i)
3513: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3514{
3515 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3516 throw std::runtime_error("muVHbb called with a class whose parent is not NPbase");
3517}
3518
3520{
3521 if ((this->getModel()).isModelLinearized()) {
3522 return ( -1.0 + (myNPbase->muVH(sqrt_s)) + (myNPbase->BrHccRatio()));
3523 } else {
3524 return myNPbase->muVHcc(sqrt_s);
3525 }
3526}
3527
3528
3529muVBFBRinv::muVBFBRinv(const StandardModel& SM_i, const double sqrt_s_i)
3530: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3531{
3532 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3533 throw std::runtime_error("muVBFBRinv called with a class whose parent is not NPbase");
3534}
3535
3537{
3538
3539 return (myNPbase->muVBF(sqrt_s))*(myNPbase->Br_H_inv());
3540
3541}
3542
3543muVBFHinv::muVBFHinv(const StandardModel& SM_i, const double sqrt_s_i)
3544: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3545{
3546 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3547 throw std::runtime_error("muVBFHinv called with a class whose parent is not NPbase");
3548}
3549
3551{
3552
3553 if ((this->getModel()).isModelLinearized()) {
3554 return ((myNPbase->muVBF(sqrt_s)) + (myNPbase->BrHtoinvRatio()) - 1.0);
3555 } else {
3556 return (myNPbase->muVBF(sqrt_s))*(myNPbase->BrHtoinvRatio());
3557 }
3558
3559}
3560
3561
3562muVHBRinv::muVHBRinv(const StandardModel& SM_i, const double sqrt_s_i)
3563: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3564{
3565 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3566 throw std::runtime_error("muVHBRinv called with a class whose parent is not NPbase");
3567}
3568
3570{
3571
3572 return (myNPbase->muVH(sqrt_s))*(myNPbase->Br_H_inv());
3573
3574}
3575
3576muVHinv::muVHinv(const StandardModel& SM_i, const double sqrt_s_i)
3577: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3578{
3579 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3580 throw std::runtime_error("muVHinv called with a class whose parent is not NPbase");
3581}
3582
3584{
3585
3586 if ((this->getModel()).isModelLinearized()) {
3587 return ((myNPbase->muVH(sqrt_s)) + (myNPbase->BrHtoinvRatio()) - 1.0);
3588 } else {
3589 return (myNPbase->muVH(sqrt_s))*(myNPbase->BrHtoinvRatio());
3590 }
3591
3592}
3593
3594
3595muppHmumu::muppHmumu(const StandardModel& SM_i, const double sqrt_s_i)
3596: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3597{
3598 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3599 throw std::runtime_error("muppHmumu called with a class whose parent is not NPbase");
3600}
3601
3603{
3604 return myNPbase->muppHmumu(sqrt_s);
3605}
3606
3607muppHZga::muppHZga(const StandardModel& SM_i, const double sqrt_s_i)
3608: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3609{
3610 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3611 throw std::runtime_error("muppHZga called with a class whose parent is not NPbase");
3612}
3613
3615{
3616 return myNPbase->muppHZga(sqrt_s);
3617}
3618
3619muggHH2ga2b::muggHH2ga2b(const StandardModel& SM_i, const double sqrt_s_i)
3620: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3621{
3622 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3623 throw std::runtime_error("muggH called with a class whose parent is not NPbase");
3624}
3625
3627{
3628 if ((this->getModel()).isModelLinearized()) {
3629 return (-2.0 + (myNPbase->muggHH(sqrt_s)) + (myNPbase->BrHgagaRatio()) + (myNPbase->BrHbbRatio()));
3630 } else {
3632 }
3633}
3634
3635muttHZbbboost::muttHZbbboost(const StandardModel& SM_i, const double sqrt_s_i)
3636: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3637{
3638 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3639 throw std::runtime_error("muttHZbbboost called with a class whose parent is not NPbase");
3640}
3641
3643{
3644 return (myNPbase->muttHZbbboost(sqrt_s));
3645}
3646
3647//AG:begin
3648ggHgaga::ggHgaga(const StandardModel& SM_i, const double sqrt_s_i)
3649: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3650{
3651 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3652 throw std::runtime_error("ggHgaga called with a class whose parent is not NPbase");
3653}
3655{
3656 double SM_prediction = 0.0439; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3657 if ((this->getModel()).isModelLinearized()) {
3658 return SM_prediction*( 1. + (myNPbase->muggH(sqrt_s)-1.) + (myNPbase->BrHgagaRatio()-1.) );
3659 } else {
3660 return SM_prediction*(myNPbase->muggH(sqrt_s))*(myNPbase->BrHgagaRatio());
3661 }
3662}
3663
3664
3665ggHZZ::ggHZZ(const StandardModel& SM_i, const double sqrt_s_i)
3666: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3667{
3668 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3669 throw std::runtime_error("ggHZZ called with a class whose parent is not NPbase");
3670}
3672{
3673 double SM_prediction = 0.5197; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3674 if ((this->getModel()).isModelLinearized()) {
3675 return SM_prediction*( 1. + (myNPbase->muggH(sqrt_s)-1.) + (myNPbase->BrHZZRatio()-1.) );
3676 } else {
3677 return SM_prediction*(myNPbase->muggH(sqrt_s))*(myNPbase->BrHZZRatio());
3678 }
3679}
3680
3681
3682ggHWW::ggHWW(const StandardModel& SM_i, const double sqrt_s_i)
3683: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3684{
3685 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3686 throw std::runtime_error("ggHWW called with a class whose parent is not NPbase");
3687}
3689{
3690 double SM_prediction = 4.1603; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3691 if ((this->getModel()).isModelLinearized()) {
3692 return SM_prediction*( 1. + (myNPbase->muggH(sqrt_s)-1.) + (myNPbase->BrHWWRatio()-1.) );
3693 } else {
3694 return SM_prediction*(myNPbase->muggH(sqrt_s))*(myNPbase->BrHWWRatio());
3695 }
3696}
3697
3698
3699ggHtautau::ggHtautau(const StandardModel& SM_i, const double sqrt_s_i)
3700: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3701{
3702 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3703 throw std::runtime_error("ggHtautau called with a class whose parent is not NPbase");
3704}
3706{
3707 double SM_prediction = 1.2215; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3708 if ((this->getModel()).isModelLinearized()) {
3709 return SM_prediction*( 1. + (myNPbase->muggH(sqrt_s)-1.) + (myNPbase->BrHtautauRatio()-1.) );
3710 } else {
3711 return SM_prediction*(myNPbase->muggH(sqrt_s))*(myNPbase->BrHtautauRatio());
3712 }
3713}
3714
3715
3716VBFHgaga::VBFHgaga(const StandardModel& SM_i, const double sqrt_s_i)
3717: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3718{
3719 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3720 throw std::runtime_error("VBFHgaga called with a class whose parent is not NPbase");
3721}
3723{
3724 double SM_prediction = 0.0037; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3725 if ((this->getModel()).isModelLinearized()) {
3726 return SM_prediction*( 1. + (myNPbase->muVBF(sqrt_s)-1.) + (myNPbase->BrHgagaRatio()-1.) );
3727 } else {
3728 return SM_prediction*(myNPbase->muVBF(sqrt_s))*(myNPbase->BrHgagaRatio());
3729 }
3730}
3731
3732
3733VBFHZZ::VBFHZZ(const StandardModel& SM_i, const double sqrt_s_i)
3734: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3735{
3736 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3737 throw std::runtime_error("VBFHZZ called with a class whose parent is not NPbase");
3738}
3740{
3741 double SM_prediction = 0.0530; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3742 if ((this->getModel()).isModelLinearized()) {
3743 return SM_prediction*( 1. + (myNPbase->muVBF(sqrt_s)-1.) + (myNPbase->BrHZZRatio()-1.) );
3744 } else {
3745 return SM_prediction*(myNPbase->muVBF(sqrt_s))*(myNPbase->BrHZZRatio());
3746 }
3747}
3748
3749
3750VBFHWW::VBFHWW(const StandardModel& SM_i, const double sqrt_s_i)
3751: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3752{
3753 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3754 throw std::runtime_error("VBFHWW called with a class whose parent is not NPbase");
3755}
3757{
3758 double SM_prediction = 0.3494; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3759 if ((this->getModel()).isModelLinearized()) {
3760 return SM_prediction*( 1. + (myNPbase->muVBF(sqrt_s)-1.) + (myNPbase->BrHWWRatio()-1.) );
3761 } else {
3762 return SM_prediction*(myNPbase->muVBF(sqrt_s))*(myNPbase->BrHWWRatio());
3763 }
3764}
3765
3766
3767VBFHtautau::VBFHtautau(const StandardModel& SM_i, const double sqrt_s_i)
3768: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3769{
3770 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3771 throw std::runtime_error("VBFHtautau called with a class whose parent is not NPbase");
3772}
3774{
3775 double SM_prediction = 0.1011; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3776 if ((this->getModel()).isModelLinearized()) {
3777 return SM_prediction*( 1. + (myNPbase->muVBF(sqrt_s)-1.) + (myNPbase->BrHtautauRatio()-1.) );
3778 } else {
3779 return SM_prediction*(myNPbase->muVBF(sqrt_s))*(myNPbase->BrHtautauRatio());
3780 }
3781}
3782
3783
3784WHgaga::WHgaga(const StandardModel& SM_i, const double sqrt_s_i)
3785: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3786{
3787 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3788 throw std::runtime_error("WHgaga called with a class whose parent is not NPbase");
3789}
3791{
3792 double SM_prediction = 0.0017; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3793 if ((this->getModel()).isModelLinearized()) {
3794 return SM_prediction*( 1. + (myNPbase->muWH(sqrt_s)-1.) + (myNPbase->BrHgagaRatio()-1.) );
3795 } else {
3796 return SM_prediction*(myNPbase->muWH(sqrt_s))*(myNPbase->BrHgagaRatio());
3797 }
3798}
3799
3800
3801WHWW::WHWW(const StandardModel& SM_i, const double sqrt_s_i)
3802: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3803{
3804 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3805 throw std::runtime_error("WHWW called with a class whose parent is not NPbase");
3806}
3808{
3809 double SM_prediction = 0.1614; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3810 if ((this->getModel()).isModelLinearized()) {
3811 return SM_prediction*( 1. + (myNPbase->muWH(sqrt_s)-1.) + (myNPbase->BrHWWRatio()-1.) );
3812 } else {
3813 return SM_prediction*(myNPbase->muWH(sqrt_s))*(myNPbase->BrHWWRatio());
3814 }
3815}
3816
3817
3818WHtautau::WHtautau(const StandardModel& SM_i, const double sqrt_s_i)
3819: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3820{
3821 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3822 throw std::runtime_error("WWHtautau called with a class whose parent is not NPbase");
3823}
3825{
3826 double SM_prediction = 0.0462; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3827 if ((this->getModel()).isModelLinearized()) {
3828 return SM_prediction*( 1. + (myNPbase->muWH(sqrt_s)-1.) + (myNPbase->BrHtautauRatio()-1.) );
3829 } else {
3830 return SM_prediction*(myNPbase->muWH(sqrt_s))*(myNPbase->BrHtautauRatio());
3831 }
3832}
3833
3834
3835WHbb::WHbb(const StandardModel& SM_i, const double sqrt_s_i)
3836: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3837{
3838 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3839 throw std::runtime_error("WHbb called with a class whose parent is not NPbase");
3840}
3842{
3843 double SM_prediction = 0.4090; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3844 if ((this->getModel()).isModelLinearized()) {
3845 return SM_prediction*( 1. + (myNPbase->muWH(sqrt_s)-1.) + (myNPbase->BrHbbRatio()-1.) );
3846 } else {
3847 return SM_prediction*(myNPbase->muWH(sqrt_s))*(myNPbase->BrHbbRatio());
3848 }
3849}
3850
3851
3852ZHgaga::ZHgaga(const StandardModel& SM_i, const double sqrt_s_i)
3853: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3854{
3855 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3856 throw std::runtime_error("ZHgaga called with a class whose parent is not NPbase");
3857}
3859{
3860 double SM_prediction = 0.0011; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3861 if ((this->getModel()).isModelLinearized()) {
3862 return SM_prediction*( 1. + (myNPbase->muZH(sqrt_s)-1.) + (myNPbase->BrHgagaRatio()-1.) );
3863 } else {
3864 return SM_prediction*(myNPbase->muZH(sqrt_s))*(myNPbase->BrHgagaRatio());
3865 }
3866}
3867
3868
3869ZHWW::ZHWW(const StandardModel& SM_i, const double sqrt_s_i)
3870: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3871{
3872 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3873 throw std::runtime_error("ZHWW called with a class whose parent is not NPbase");
3874}
3876{
3877 double SM_prediction = 0.0996; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3878 if ((this->getModel()).isModelLinearized()) {
3879 return SM_prediction*( 1. + (myNPbase->muZH(sqrt_s)-1.) + (myNPbase->BrHWWRatio()-1.) );
3880 } else {
3881 return SM_prediction*(myNPbase->muZH(sqrt_s))*(myNPbase->BrHWWRatio());
3882 }
3883}
3884
3885
3886ZHtautau::ZHtautau(const StandardModel& SM_i, const double sqrt_s_i)
3887: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3888{
3889 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3890 throw std::runtime_error("ZHtautau called with a class whose parent is not NPbase");
3891}
3893{
3894 double SM_prediction = 0.0304; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3895 if ((this->getModel()).isModelLinearized()) {
3896 return SM_prediction*( 1. + (myNPbase->muZH(sqrt_s)-1.) + (myNPbase->BrHtautauRatio()-1.) );
3897 } else {
3898 return SM_prediction*(myNPbase->muZH(sqrt_s))*(myNPbase->BrHtautauRatio());
3899 }
3900}
3901
3902
3903ZHbb::ZHbb(const StandardModel& SM_i, const double sqrt_s_i)
3904: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3905{
3906 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3907 throw std::runtime_error("ZHbb called with a class whose parent is not NPbase");
3908}
3910{
3911 double SM_prediction = 0.2410; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3912 if ((this->getModel()).isModelLinearized()) {
3913 return SM_prediction*( 1. + (myNPbase->muZH(sqrt_s)-1.) + (myNPbase->BrHbbRatio()-1.) );
3914 } else {
3915 return SM_prediction*(myNPbase->muZH(sqrt_s))*(myNPbase->BrHbbRatio());
3916 }
3917}
3918
3919
3920ttHgaga::ttHgaga(const StandardModel& SM_i, const double sqrt_s_i)
3921: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3922{
3923 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3924 throw std::runtime_error("ttHgaga called with a class whose parent is not NPbase");
3925}
3927{
3928 double SM_prediction = 0.0004; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3929 if ((this->getModel()).isModelLinearized()) {
3930 return SM_prediction*( 1. + (myNPbase->muttH(sqrt_s)-1.) + (myNPbase->BrHgagaRatio()-1.) );
3931 } else {
3932 return SM_prediction*(myNPbase->muttH(sqrt_s))*(myNPbase->BrHgagaRatio());
3933 }
3934}
3935
3936
3937ttHWW::ttHWW(const StandardModel& SM_i, const double sqrt_s_i)
3938: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3939{
3940 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3941 throw std::runtime_error("ttHWW called with a class whose parent is not NPbase");
3942}
3944{
3945 double SM_prediction = 0.0281; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3946 if ((this->getModel()).isModelLinearized()) {
3947 return SM_prediction*( 1. + (myNPbase->muttH(sqrt_s)-1.) + (myNPbase->BrHWWRatio()-1.) );
3948 } else {
3949 return SM_prediction*(myNPbase->muttH(sqrt_s))*(myNPbase->BrHWWRatio());
3950 }
3951}
3952
3953
3954ttHtautau::ttHtautau(const StandardModel& SM_i, const double sqrt_s_i)
3955: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3956{
3957 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3958 throw std::runtime_error("ttHtautau called with a class whose parent is not NPbase");
3959}
3961{
3962 double SM_prediction = 0.0106; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3963 if ((this->getModel()).isModelLinearized()) {
3964 return SM_prediction*( 1. + (myNPbase->muttH(sqrt_s)-1.) + (myNPbase->BrHtautauRatio()-1.) );
3965 } else {
3966 return SM_prediction*(myNPbase->muttH(sqrt_s))*(myNPbase->BrHtautauRatio());
3967 }
3968}
3969
3970
3971ttHbb::ttHbb(const StandardModel& SM_i, const double sqrt_s_i)
3972: ThObservable(SM_i), sqrt_s(sqrt_s_i)
3973{
3974 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3975 throw std::runtime_error("ttHbb called with a class whose parent is not NPbase");
3976}
3978{
3979 double SM_prediction = 0.0751; //Ref:https://www.hepdata.net/record/ins1468068, Table1 (after symmetrizing)
3980 if ((this->getModel()).isModelLinearized()) {
3981 return SM_prediction*( 1. + (myNPbase->muttH(sqrt_s)-1.) + (myNPbase->BrHbbRatio()-1.) );
3982 } else {
3983 return SM_prediction*(myNPbase->muttH(sqrt_s))*(myNPbase->BrHbbRatio());
3984 }
3985}
3986
3987//AG:end
3988
3989UpperLimit_ppHZgammaA::UpperLimit_ppHZgammaA(const StandardModel& SM_i, const double sqrt_s_i) : ThObservable(SM_i), sqrt_s(sqrt_s_i)
3990{
3991 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
3992 throw std::runtime_error("UpperLimit_ppHZgammaA called with a class whose parent is not NPbase");
3993}
3994
3996{
3998}
3999
4000UpperLimit_ppHZgammaA13::UpperLimit_ppHZgammaA13(const StandardModel& SM_i, const double sqrt_s_i) : ThObservable(SM_i), sqrt_s(sqrt_s_i)
4001{
4002 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4003 throw std::runtime_error("UpperLimit_ppHZgammaA13 called with a class whose parent is not NPbase");
4004}
4005
4007{
4009}
4010
4011UpperLimit_ppHZgammaC13::UpperLimit_ppHZgammaC13(const StandardModel& SM_i, const double sqrt_s_i) : ThObservable(SM_i), sqrt_s(sqrt_s_i)
4012{
4013 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4014 throw std::runtime_error("UpperLimit_ppHZgammaC13 called with a class whose parent is not NPbase");
4015}
4016
4018{
4020}
4021
4022UpperLimit_ppHZgammaC::UpperLimit_ppHZgammaC(const StandardModel& SM_i, const double sqrt_s_i) : ThObservable(SM_i), sqrt_s(sqrt_s_i)
4023{
4024 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4025 throw std::runtime_error("UpperLimit_ppHZgammaC called with a class whose parent is not NPbase");
4026}
4027
4029{
4031}
4032
4034{
4035 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4036 throw std::runtime_error("cg_plus_ct called with a class whose parent is not NPbase");
4037}
4038
4040{
4041 return myNPbase->cgplusct();
4042}
4043
4045{
4046 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4047 throw std::runtime_error("cga_plus_ct called with a class whose parent is not NPbase");
4048}
4049
4051{
4052 return myNPbase->cgaplusct();
4053}
4054
4056{
4057 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4058 throw std::runtime_error("cg_minus_cga called with a class whose parent is not NPbase");
4059}
4060
4062{
4063 return myNPbase->cgminuscga();
4064}
4065
4067{
4068 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4069 throw std::runtime_error("cV_plus_cb called with a class whose parent is not NPbase");
4070}
4071\
4072
4073
4075{
4076 return myNPbase->cVpluscb();
4077}
4078
4080{
4081 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4082 throw std::runtime_error("cV_plus_ctau called with a class whose parent is not NPbase");
4083}
4084
4086{
4087 return myNPbase->cVplusctau();
4088}
4089
4091{
4092 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4093 throw std::runtime_error("cb_minus_cc called with a class whose parent is not NPbase");
4094}
4095
4097{
4098 return myNPbase->cbminuscc();
4099}
4100
4102{
4103 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4104 throw std::runtime_error("cb_minus_ctau called with a class whose parent is not NPbase");
4105}
4106
4108{
4109 return myNPbase->cbminusctau();
4110}
4111
4113{
4114 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4115 throw std::runtime_error("cc_minus_ctau called with a class whose parent is not NPbase");
4116}
4117
4119{
4120 return myNPbase->ccminusctau();
4121}
4122
4123
4124// Full signal strengths at e+ e- colliders
4125// ----------------------------------------
4126
4127mueeZHbb::mueeZHbb(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4128: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4129{
4130 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4131 throw std::runtime_error("mueeZHbb called with a class whose parent is not NPbase");
4132}
4133
4135{
4136 if ((this->getModel()).isModelLinearized()) {
4137 return ((myNPbase->mueeZH(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHbbRatio()) - 1.0);
4138 } else {
4140 }
4141}
4142
4143mueeZHcc::mueeZHcc(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4144: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4145{
4146 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4147 throw std::runtime_error("mueeZHcc called with a class whose parent is not NPbase");
4148}
4149
4151{
4152 if ((this->getModel()).isModelLinearized()) {
4153 return ((myNPbase->mueeZH(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHccRatio()) - 1.0);
4154 } else {
4156 }
4157}
4158
4159mueeZHss::mueeZHss(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4160: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4161{
4162 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4163 throw std::runtime_error("mueeZHss called with a class whose parent is not NPbase");
4164}
4165
4167{
4168 if ((this->getModel()).isModelLinearized()) {
4169 return ((myNPbase->mueeZH(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHssRatio()) - 1.0);
4170 } else {
4172 }
4173}
4174
4175mueeZHgg::mueeZHgg(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4176: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4177{
4178 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4179 throw std::runtime_error("mueeZHgg called with a class whose parent is not NPbase");
4180}
4181
4183{
4184 if ((this->getModel()).isModelLinearized()) {
4185 return ((myNPbase->mueeZH(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHggRatio()) - 1.0);
4186 } else {
4188 }
4189}
4190
4191mueeZHWW::mueeZHWW(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4192: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4193{
4194 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4195 throw std::runtime_error("mueeZHWW called with a class whose parent is not NPbase");
4196}
4197
4199{
4200 if ((this->getModel()).isModelLinearized()) {
4201 return ((myNPbase->mueeZH(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHWWRatio()) - 1.0);
4202 } else {
4204 }
4205}
4206
4207mueeZHtautau::mueeZHtautau(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4208: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4209{
4210 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4211 throw std::runtime_error("mueeZHtautau called with a class whose parent is not NPbase");
4212}
4213
4215{
4216 if ((this->getModel()).isModelLinearized()) {
4217 return ((myNPbase->mueeZH(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHtautauRatio()) - 1.0);
4218 } else {
4220 }
4221}
4222
4223mueeZHZZ::mueeZHZZ(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4224: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4225{
4226 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4227 throw std::runtime_error("mueeZHZZ called with a class whose parent is not NPbase");
4228}
4229
4231{
4232 if ((this->getModel()).isModelLinearized()) {
4233 return ((myNPbase->mueeZH(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHZZRatio()) - 1.0);
4234 } else {
4236 }
4237}
4238
4239mueeZHZga::mueeZHZga(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4240: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4241{
4242 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4243 throw std::runtime_error("mueeZHZga called with a class whose parent is not NPbase");
4244}
4245
4247{
4248 if ((this->getModel()).isModelLinearized()) {
4249 return ((myNPbase->mueeZH(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHZgaRatio()) - 1.0);
4250 } else {
4252 }
4253}
4254
4255mueeZHgaga::mueeZHgaga(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4256: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4257{
4258 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4259 throw std::runtime_error("mueeZHgaga called with a class whose parent is not NPbase");
4260}
4261
4263{
4264 if ((this->getModel()).isModelLinearized()) {
4265 return ((myNPbase->mueeZH(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHgagaRatio()) - 1.0);
4266 } else {
4268 }
4269}
4270
4271mueeZHmumu::mueeZHmumu(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4272: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4273{
4274 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4275 throw std::runtime_error("mueeZHmumu called with a class whose parent is not NPbase");
4276}
4277
4279{
4280 if ((this->getModel()).isModelLinearized()) {
4281 return ((myNPbase->mueeZH(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHmumuRatio()) - 1.0);
4282 } else {
4284 }
4285}
4286
4287mueeZHBRinv::mueeZHBRinv(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4288: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4289{
4290 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4291 throw std::runtime_error("mueeZHBRinv called with a class whose parent is not NPbase");
4292}
4293
4295{
4296
4298
4299}
4300
4301mueeZHinv::mueeZHinv(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4302: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4303{
4304 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4305 throw std::runtime_error("mueeZHinv called with a class whose parent is not NPbase");
4306}
4307
4309{
4310
4311 if ((this->getModel()).isModelLinearized()) {
4312 return ((myNPbase->mueeZH(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHtoinvRatio()) - 1.0);
4313 } else {
4315 }
4316
4317}
4318
4319mueeWBFbb::mueeWBFbb(const StandardModel& SM_i, const double sqrt_s_i)
4320: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4321{
4322 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4323 throw std::runtime_error("mueeWBFbb called with a class whose parent is not NPbase");
4324
4325}
4326
4328{
4329 if ((this->getModel()).isModelLinearized()) {
4330 return ((myNPbase->mueeWBF(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
4331 } else {
4332 return (myNPbase->mueeWBF(sqrt_s))*(myNPbase->BrHbbRatio());
4333 }
4334}
4335
4336mueeWBFbbPol::mueeWBFbbPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4337: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4338{
4339 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4340 throw std::runtime_error("mueeWBFbbPol called with a class whose parent is not NPbase");
4341
4342}
4343
4345{
4346 if ((this->getModel()).isModelLinearized()) {
4347 return ((myNPbase->mueeWBFPol(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHbbRatio()) - 1.0);
4348 } else {
4350 }
4351}
4352
4353mueeWBFcc::mueeWBFcc(const StandardModel& SM_i, const double sqrt_s_i)
4354: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4355{
4356 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4357 throw std::runtime_error("mueeWBFcc called with a class whose parent is not NPbase");
4358
4359}
4360
4362{
4363 if ((this->getModel()).isModelLinearized()) {
4364 return ((myNPbase->mueeWBF(sqrt_s)) + (myNPbase->BrHccRatio()) - 1.0);
4365 } else {
4366 return (myNPbase->mueeWBF(sqrt_s))*(myNPbase->BrHccRatio());
4367 }
4368}
4369
4370mueeWBFgg::mueeWBFgg(const StandardModel& SM_i, const double sqrt_s_i)
4371: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4372{
4373 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4374 throw std::runtime_error("mueeWBFgg called with a class whose parent is not NPbase");
4375
4376}
4377
4379{
4380 if ((this->getModel()).isModelLinearized()) {
4381 return ((myNPbase->mueeWBF(sqrt_s)) + (myNPbase->BrHggRatio()) - 1.0);
4382 } else {
4383 return (myNPbase->mueeWBF(sqrt_s))*(myNPbase->BrHggRatio());
4384 }
4385}
4386
4387mueeWBFWW::mueeWBFWW(const StandardModel& SM_i, const double sqrt_s_i)
4388: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4389{
4390 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4391 throw std::runtime_error("mueeWBFWW called with a class whose parent is not NPbase");
4392
4393}
4394
4396{
4397 if ((this->getModel()).isModelLinearized()) {
4398 return ((myNPbase->mueeWBF(sqrt_s)) + (myNPbase->BrHWWRatio()) - 1.0);
4399 } else {
4400 return (myNPbase->mueeWBF(sqrt_s))*(myNPbase->BrHWWRatio());
4401 }
4402}
4403
4404mueeWBFtautau::mueeWBFtautau(const StandardModel& SM_i, const double sqrt_s_i)
4405: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4406{
4407 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4408 throw std::runtime_error("mueeWBFtautau called with a class whose parent is not NPbase");
4409
4410}
4411
4413{
4414 if ((this->getModel()).isModelLinearized()) {
4415 return ((myNPbase->mueeWBF(sqrt_s)) + (myNPbase->BrHtautauRatio()) - 1.0);
4416 } else {
4418 }
4419}
4420
4421mueeWBFZZ::mueeWBFZZ(const StandardModel& SM_i, const double sqrt_s_i)
4422: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4423{
4424 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4425 throw std::runtime_error("mueeWBFZZ called with a class whose parent is not NPbase");
4426
4427}
4428
4430{
4431 if ((this->getModel()).isModelLinearized()) {
4432 return ((myNPbase->mueeWBF(sqrt_s)) + (myNPbase->BrHZZRatio()) - 1.0);
4433 } else {
4434 return (myNPbase->mueeWBF(sqrt_s))*(myNPbase->BrHZZRatio());
4435 }
4436}
4437
4438mueeWBFZga::mueeWBFZga(const StandardModel& SM_i, const double sqrt_s_i)
4439: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4440{
4441 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4442 throw std::runtime_error("mueeWBFZga called with a class whose parent is not NPbase");
4443
4444}
4445
4447{
4448 if ((this->getModel()).isModelLinearized()) {
4449 return ((myNPbase->mueeWBF(sqrt_s)) + (myNPbase->BrHZgaRatio()) - 1.0);
4450 } else {
4451 return (myNPbase->mueeWBF(sqrt_s))*(myNPbase->BrHZgaRatio());
4452 }
4453}
4454
4455mueeWBFgaga::mueeWBFgaga(const StandardModel& SM_i, const double sqrt_s_i)
4456: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4457{
4458 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4459 throw std::runtime_error("mueeWBFgaga called with a class whose parent is not NPbase");
4460
4461}
4462
4464{
4465 if ((this->getModel()).isModelLinearized()) {
4466 return ((myNPbase->mueeWBF(sqrt_s)) + (myNPbase->BrHgagaRatio()) - 1.0);
4467 } else {
4469 }
4470}
4471
4472mueeWBFmumu::mueeWBFmumu(const StandardModel& SM_i, const double sqrt_s_i)
4473: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4474{
4475 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4476 throw std::runtime_error("mueeWBFmumu called with a class whose parent is not NPbase");
4477
4478}
4479
4481{
4482 if ((this->getModel()).isModelLinearized()) {
4483 return ((myNPbase->mueeWBF(sqrt_s)) + (myNPbase->BrHmumuRatio()) - 1.0);
4484 } else {
4486 }
4487}
4488
4489mueeHvvbb::mueeHvvbb(const StandardModel& SM_i, const double sqrt_s_i)
4490: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4491{
4492 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4493 throw std::runtime_error("mueeHvvbb called with a class whose parent is not NPbase");
4494
4495}
4496
4498{
4499 if ((this->getModel()).isModelLinearized()) {
4500 return ((myNPbase->mueeHvv(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
4501 } else {
4502 return (myNPbase->mueeHvv(sqrt_s))*(myNPbase->BrHbbRatio());
4503 }
4504}
4505
4506mueeHvvbbPol::mueeHvvbbPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4507: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4508{
4509 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4510 throw std::runtime_error("mueeHvvbbPol called with a class whose parent is not NPbase");
4511
4512}
4513
4515{
4516 if ((this->getModel()).isModelLinearized()) {
4517 return ((myNPbase->mueeHvvPol(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHbbRatio()) - 1.0);
4518 } else {
4520 }
4521}
4522
4523mueeHvvcc::mueeHvvcc(const StandardModel& SM_i, const double sqrt_s_i)
4524: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4525{
4526 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4527 throw std::runtime_error("mueeHvvcc called with a class whose parent is not NPbase");
4528
4529}
4530
4532{
4533 if ((this->getModel()).isModelLinearized()) {
4534 return ((myNPbase->mueeHvv(sqrt_s)) + (myNPbase->BrHccRatio()) - 1.0);
4535 } else {
4536 return (myNPbase->mueeHvv(sqrt_s))*(myNPbase->BrHccRatio());
4537 }
4538}
4539
4540mueeHvvccPol::mueeHvvccPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4541: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4542{
4543 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4544 throw std::runtime_error("mueeHvvccPol called with a class whose parent is not NPbase");
4545
4546}
4547
4549{
4550 if ((this->getModel()).isModelLinearized()) {
4551 return ((myNPbase->mueeHvvPol(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHccRatio()) - 1.0);
4552 } else {
4554 }
4555}
4556
4557mueeHvvgg::mueeHvvgg(const StandardModel& SM_i, const double sqrt_s_i)
4558: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4559{
4560 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4561 throw std::runtime_error("mueeHvvgg called with a class whose parent is not NPbase");
4562
4563}
4564
4566{
4567 if ((this->getModel()).isModelLinearized()) {
4568 return ((myNPbase->mueeHvv(sqrt_s)) + (myNPbase->BrHggRatio()) - 1.0);
4569 } else {
4570 return (myNPbase->mueeHvv(sqrt_s))*(myNPbase->BrHggRatio());
4571 }
4572}
4573
4574mueeHvvggPol::mueeHvvggPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4575: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4576{
4577 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4578 throw std::runtime_error("mueeHvvggPol called with a class whose parent is not NPbase");
4579
4580}
4581
4583{
4584 if ((this->getModel()).isModelLinearized()) {
4585 return ((myNPbase->mueeHvvPol(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHggRatio()) - 1.0);
4586 } else {
4588 }
4589}
4590
4591mueeHvvWW::mueeHvvWW(const StandardModel& SM_i, const double sqrt_s_i)
4592: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4593{
4594 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4595 throw std::runtime_error("mueeHvvWW called with a class whose parent is not NPbase");
4596
4597}
4598
4600{
4601 if ((this->getModel()).isModelLinearized()) {
4602 return ((myNPbase->mueeHvv(sqrt_s)) + (myNPbase->BrHWWRatio()) - 1.0);
4603 } else {
4604 return (myNPbase->mueeHvv(sqrt_s))*(myNPbase->BrHWWRatio());
4605 }
4606}
4607
4608mueeHvvWWPol::mueeHvvWWPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4609: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4610{
4611 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4612 throw std::runtime_error("mueeHvvWWPol called with a class whose parent is not NPbase");
4613
4614}
4615
4617{
4618 if ((this->getModel()).isModelLinearized()) {
4619 return ((myNPbase->mueeHvvPol(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHWWRatio()) - 1.0);
4620 } else {
4622 }
4623}
4624
4625mueeHvvtautau::mueeHvvtautau(const StandardModel& SM_i, const double sqrt_s_i)
4626: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4627{
4628 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4629 throw std::runtime_error("mueeHvvtautau called with a class whose parent is not NPbase");
4630
4631}
4632
4634{
4635 if ((this->getModel()).isModelLinearized()) {
4636 return ((myNPbase->mueeHvv(sqrt_s)) + (myNPbase->BrHtautauRatio()) - 1.0);
4637 } else {
4639 }
4640}
4641
4642mueeHvvtautauPol::mueeHvvtautauPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4643: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4644{
4645 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4646 throw std::runtime_error("mueeHvvtautauPol called with a class whose parent is not NPbase");
4647
4648}
4649
4651{
4652 if ((this->getModel()).isModelLinearized()) {
4653 return ((myNPbase->mueeHvvPol(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHtautauRatio()) - 1.0);
4654 } else {
4656 }
4657}
4658
4659mueeHvvZZ::mueeHvvZZ(const StandardModel& SM_i, const double sqrt_s_i)
4660: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4661{
4662 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4663 throw std::runtime_error("mueeHvvZZ called with a class whose parent is not NPbase");
4664
4665}
4666
4668{
4669 if ((this->getModel()).isModelLinearized()) {
4670 return ((myNPbase->mueeHvv(sqrt_s)) + (myNPbase->BrHZZRatio()) - 1.0);
4671 } else {
4672 return (myNPbase->mueeHvv(sqrt_s))*(myNPbase->BrHZZRatio());
4673 }
4674}
4675
4676mueeHvvZZPol::mueeHvvZZPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4677: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4678{
4679 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4680 throw std::runtime_error("mueeHvvZZPol called with a class whose parent is not NPbase");
4681
4682}
4683
4685{
4686 if ((this->getModel()).isModelLinearized()) {
4687 return ((myNPbase->mueeHvvPol(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHZZRatio()) - 1.0);
4688 } else {
4690 }
4691}
4692
4693mueeHvvZga::mueeHvvZga(const StandardModel& SM_i, const double sqrt_s_i)
4694: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4695{
4696 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4697 throw std::runtime_error("mueeHvvZga called with a class whose parent is not NPbase");
4698
4699}
4700
4702{
4703 if ((this->getModel()).isModelLinearized()) {
4704 return ((myNPbase->mueeHvv(sqrt_s)) + (myNPbase->BrHZgaRatio()) - 1.0);
4705 } else {
4706 return (myNPbase->mueeHvv(sqrt_s))*(myNPbase->BrHZgaRatio());
4707 }
4708}
4709
4710mueeHvvZgaPol::mueeHvvZgaPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4711: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4712{
4713 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4714 throw std::runtime_error("mueeHvvZgaPol called with a class whose parent is not NPbase");
4715
4716}
4717
4719{
4720 if ((this->getModel()).isModelLinearized()) {
4721 return ((myNPbase->mueeHvvPol(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHZgaRatio()) - 1.0);
4722 } else {
4724 }
4725}
4726
4727mueeHvvgaga::mueeHvvgaga(const StandardModel& SM_i, const double sqrt_s_i)
4728: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4729{
4730 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4731 throw std::runtime_error("mueeHvvgaga called with a class whose parent is not NPbase");
4732
4733}
4734
4736{
4737 if ((this->getModel()).isModelLinearized()) {
4738 return ((myNPbase->mueeHvv(sqrt_s)) + (myNPbase->BrHgagaRatio()) - 1.0);
4739 } else {
4741 }
4742}
4743
4744mueeHvvgagaPol::mueeHvvgagaPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4745: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4746{
4747 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4748 throw std::runtime_error("mueeHvvgagaPol called with a class whose parent is not NPbase");
4749
4750}
4751
4753{
4754 if ((this->getModel()).isModelLinearized()) {
4755 return ((myNPbase->mueeHvvPol(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHgagaRatio()) - 1.0);
4756 } else {
4758 }
4759}
4760
4761mueeHvvmumu::mueeHvvmumu(const StandardModel& SM_i, const double sqrt_s_i)
4762: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4763{
4764 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4765 throw std::runtime_error("mueeHvvmumu called with a class whose parent is not NPbase");
4766
4767}
4768
4770{
4771 if ((this->getModel()).isModelLinearized()) {
4772 return ((myNPbase->mueeHvv(sqrt_s)) + (myNPbase->BrHmumuRatio()) - 1.0);
4773 } else {
4775 }
4776}
4777
4778mueeHvvmumuPol::mueeHvvmumuPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4779: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4780{
4781 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4782 throw std::runtime_error("mueeHvvmumuPol called with a class whose parent is not NPbase");
4783
4784}
4785
4787{
4788 if ((this->getModel()).isModelLinearized()) {
4789 return ((myNPbase->mueeHvvPol(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHmumuRatio()) - 1.0);
4790 } else {
4792 }
4793}
4794
4795mueeZBFbb::mueeZBFbb(const StandardModel& SM_i, const double sqrt_s_i)
4796: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4797{
4798 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4799 throw std::runtime_error("mueeZBFbb called with a class whose parent is not NPbase");
4800}
4801
4803{
4804 if ((this->getModel()).isModelLinearized()) {
4805 return ((myNPbase->mueeZBF(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
4806 } else {
4807 return (myNPbase->mueeZBF(sqrt_s))*(myNPbase->BrHbbRatio());
4808 }
4809}
4810
4811mueeZBFbbPol::mueeZBFbbPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4812: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4813{
4814 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4815 throw std::runtime_error("mueeZBFbbPol called with a class whose parent is not NPbase");
4816}
4817
4819{
4820 if ((this->getModel()).isModelLinearized()) {
4821 return ((myNPbase->mueeZBFPol(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHbbRatio()) - 1.0);
4822 } else {
4824 }
4825}
4826
4827mueettHbb::mueettHbb(const StandardModel& SM_i, const double sqrt_s_i)
4828: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4829{
4830 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4831 throw std::runtime_error("mueettHbb called with a class whose parent is not NPbase");
4832}
4833
4835{
4836 if ((this->getModel()).isModelLinearized()) {
4837 return ((myNPbase->mueettH(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
4838 } else {
4839 return (myNPbase->mueettH(sqrt_s))*(myNPbase->BrHbbRatio());
4840 }
4841}
4842
4843mueettHbbPol::mueettHbbPol(const StandardModel& SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
4844: ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4845{
4846 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4847 throw std::runtime_error("mueettHbbPol called with a class whose parent is not NPbase");
4848}
4849
4851{
4852 if ((this->getModel()).isModelLinearized()) {
4853 return ((myNPbase->mueettHPol(sqrt_s, Pol_em, Pol_ep)) + (myNPbase->BrHbbRatio()) - 1.0);
4854 } else {
4856 }
4857}
4858
4859
4860// Production signal strengths at mu+ mu- colliders
4861// ------------------------------------------------
4862
4863mummZH::mummZH(const StandardModel& SM_i, const double sqrt_s_i)
4864: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4865{
4866 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4867 throw std::runtime_error("mummZH called with a class whose parent is not NPbase");
4868}
4869
4871{
4872 return myNPbase->mummZH(sqrt_s);
4873}
4874
4875
4876mummHvv::mummHvv(const StandardModel& SM_i, const double sqrt_s_i)
4877: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4878{
4879 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4880 throw std::runtime_error("mummHvv called with a class whose parent is not NPbase");
4881}
4882
4884{
4885 return myNPbase->mummHvv(sqrt_s);
4886}
4887
4888
4889mummttH::mummttH(const StandardModel& SM_i, const double sqrt_s_i)
4890: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4891{
4892 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4893 throw std::runtime_error("mummttH called with a class whose parent is not NPbase");
4894}
4895
4897{
4898 return myNPbase->mummttH(sqrt_s);
4899}
4900
4901
4902// Full signal strengths at mu+ mu- colliders
4903// -------------------------------------------
4904
4905
4906mummHbb::mummHbb(const StandardModel& SM_i, const double sqrt_s_i)
4907: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4908{
4909 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4910 throw std::runtime_error("mummHbb called with a class whose parent is not NPbase");
4911}
4912
4914{
4915 if ((this->getModel()).isModelLinearized()) {
4916 return ((myNPbase->mummH(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
4917 } else {
4918 return (myNPbase->mummH(sqrt_s))*(myNPbase->BrHbbRatio());
4919 }
4920}
4921
4922mummHcc::mummHcc(const StandardModel& SM_i, const double sqrt_s_i)
4923: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4924{
4925 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4926 throw std::runtime_error("mummHcc called with a class whose parent is not NPbase");
4927}
4928
4930{
4931 if ((this->getModel()).isModelLinearized()) {
4932 return ((myNPbase->mummH(sqrt_s)) + (myNPbase->BrHccRatio()) - 1.0);
4933 } else {
4934 return (myNPbase->mummH(sqrt_s))*(myNPbase->BrHccRatio());
4935 }
4936}
4937
4938mummHgg::mummHgg(const StandardModel& SM_i, const double sqrt_s_i)
4939: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4940{
4941 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4942 throw std::runtime_error("mummHgg called with a class whose parent is not NPbase");
4943}
4944
4946{
4947 if ((this->getModel()).isModelLinearized()) {
4948 return ((myNPbase->mummH(sqrt_s)) + (myNPbase->BrHggRatio()) - 1.0);
4949 } else {
4950 return (myNPbase->mummH(sqrt_s))*(myNPbase->BrHggRatio());
4951 }
4952}
4953
4954mummHWW::mummHWW(const StandardModel& SM_i, const double sqrt_s_i)
4955: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4956{
4957 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4958 throw std::runtime_error("mummHcc called with a class whose parent is not NPbase");
4959}
4960
4962{
4963 if ((this->getModel()).isModelLinearized()) {
4964 return ((myNPbase->mummH(sqrt_s)) + (myNPbase->BrHWWRatio()) - 1.0);
4965 } else {
4966 return (myNPbase->mummH(sqrt_s))*(myNPbase->BrHWWRatio());
4967 }
4968}
4969
4970mummHtautau::mummHtautau(const StandardModel& SM_i, const double sqrt_s_i)
4971: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4972{
4973 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4974 throw std::runtime_error("mummHtautau called with a class whose parent is not NPbase");
4975}
4976
4978{
4979 if ((this->getModel()).isModelLinearized()) {
4980 return ((myNPbase->mummH(sqrt_s)) + (myNPbase->BrHtautauRatio()) - 1.0);
4981 } else {
4983 }
4984}
4985
4986mummHZZ::mummHZZ(const StandardModel& SM_i, const double sqrt_s_i)
4987: ThObservable(SM_i), sqrt_s(sqrt_s_i)
4988{
4989 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
4990 throw std::runtime_error("mummHZZ called with a class whose parent is not NPbase");
4991}
4992
4994{
4995 if ((this->getModel()).isModelLinearized()) {
4996 return ((myNPbase->mummH(sqrt_s)) + (myNPbase->BrHZZRatio()) - 1.0);
4997 } else {
4998 return (myNPbase->mummH(sqrt_s))*(myNPbase->BrHZZRatio());
4999 }
5000}
5001
5002mummHZga::mummHZga(const StandardModel& SM_i, const double sqrt_s_i)
5003: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5004{
5005 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5006 throw std::runtime_error("mummHZga called with a class whose parent is not NPbase");
5007}
5008
5010{
5011 if ((this->getModel()).isModelLinearized()) {
5012 return ((myNPbase->mummH(sqrt_s)) + (myNPbase->BrHZgaRatio()) - 1.0);
5013 } else {
5014 return (myNPbase->mummH(sqrt_s))*(myNPbase->BrHZgaRatio());
5015 }
5016}
5017
5018mummHgaga::mummHgaga(const StandardModel& SM_i, const double sqrt_s_i)
5019: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5020{
5021 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5022 throw std::runtime_error("mummHgaga called with a class whose parent is not NPbase");
5023}
5024
5026{
5027 if ((this->getModel()).isModelLinearized()) {
5028 return ((myNPbase->mummH(sqrt_s)) + (myNPbase->BrHgagaRatio()) - 1.0);
5029 } else {
5030 return (myNPbase->mummH(sqrt_s))*(myNPbase->BrHgagaRatio());
5031 }
5032}
5033
5034mummHmumu::mummHmumu(const StandardModel& SM_i, const double sqrt_s_i)
5035: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5036{
5037 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5038 throw std::runtime_error("mummHmumu called with a class whose parent is not NPbase");
5039}
5040
5042{
5043 if ((this->getModel()).isModelLinearized()) {
5044 return ((myNPbase->mummH(sqrt_s)) + (myNPbase->BrHmumuRatio()) - 1.0);
5045 } else {
5046 return (myNPbase->mummH(sqrt_s))*(myNPbase->BrHmumuRatio());
5047 }
5048}
5049
5050
5051
5052mummZHbb::mummZHbb(const StandardModel& SM_i, const double sqrt_s_i)
5053: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5054{
5055 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5056 throw std::runtime_error("mummZHbb called with a class whose parent is not NPbase");
5057}
5058
5060{
5061 if ((this->getModel()).isModelLinearized()) {
5062 return ((myNPbase->mummZH(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
5063 } else {
5064 return (myNPbase->mummZH(sqrt_s))*(myNPbase->BrHbbRatio());
5065 }
5066}
5067
5068mummZHcc::mummZHcc(const StandardModel& SM_i, const double sqrt_s_i)
5069: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5070{
5071 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5072 throw std::runtime_error("mummZHcc called with a class whose parent is not NPbase");
5073}
5074
5076{
5077 if ((this->getModel()).isModelLinearized()) {
5078 return ((myNPbase->mummZH(sqrt_s)) + (myNPbase->BrHccRatio()) - 1.0);
5079 } else {
5080 return (myNPbase->mummZH(sqrt_s))*(myNPbase->BrHccRatio());
5081 }
5082}
5083
5084mummZHgg::mummZHgg(const StandardModel& SM_i, const double sqrt_s_i)
5085: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5086{
5087 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5088 throw std::runtime_error("mummZHgg called with a class whose parent is not NPbase");
5089}
5090
5092{
5093 if ((this->getModel()).isModelLinearized()) {
5094 return ((myNPbase->mummZH(sqrt_s)) + (myNPbase->BrHggRatio()) - 1.0);
5095 } else {
5096 return (myNPbase->mummZH(sqrt_s))*(myNPbase->BrHggRatio());
5097 }
5098}
5099
5100mummZHWW::mummZHWW(const StandardModel& SM_i, const double sqrt_s_i)
5101: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5102{
5103 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5104 throw std::runtime_error("mummZHcc called with a class whose parent is not NPbase");
5105}
5106
5108{
5109 if ((this->getModel()).isModelLinearized()) {
5110 return ((myNPbase->mummZH(sqrt_s)) + (myNPbase->BrHWWRatio()) - 1.0);
5111 } else {
5112 return (myNPbase->mummZH(sqrt_s))*(myNPbase->BrHWWRatio());
5113 }
5114}
5115
5116mummZHtautau::mummZHtautau(const StandardModel& SM_i, const double sqrt_s_i)
5117: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5118{
5119 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5120 throw std::runtime_error("mummZHtautau called with a class whose parent is not NPbase");
5121}
5122
5124{
5125 if ((this->getModel()).isModelLinearized()) {
5126 return ((myNPbase->mummZH(sqrt_s)) + (myNPbase->BrHtautauRatio()) - 1.0);
5127 } else {
5129 }
5130}
5131
5132mummZHZZ::mummZHZZ(const StandardModel& SM_i, const double sqrt_s_i)
5133: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5134{
5135 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5136 throw std::runtime_error("mummZHZZ called with a class whose parent is not NPbase");
5137}
5138
5140{
5141 if ((this->getModel()).isModelLinearized()) {
5142 return ((myNPbase->mummZH(sqrt_s)) + (myNPbase->BrHZZRatio()) - 1.0);
5143 } else {
5144 return (myNPbase->mummZH(sqrt_s))*(myNPbase->BrHZZRatio());
5145 }
5146}
5147
5148mummZHZga::mummZHZga(const StandardModel& SM_i, const double sqrt_s_i)
5149: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5150{
5151 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5152 throw std::runtime_error("mummZHZga called with a class whose parent is not NPbase");
5153}
5154
5156{
5157 if ((this->getModel()).isModelLinearized()) {
5158 return ((myNPbase->mummZH(sqrt_s)) + (myNPbase->BrHZgaRatio()) - 1.0);
5159 } else {
5160 return (myNPbase->mummZH(sqrt_s))*(myNPbase->BrHZgaRatio());
5161 }
5162}
5163
5164mummZHgaga::mummZHgaga(const StandardModel& SM_i, const double sqrt_s_i)
5165: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5166{
5167 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5168 throw std::runtime_error("mummZHgaga called with a class whose parent is not NPbase");
5169}
5170
5172{
5173 if ((this->getModel()).isModelLinearized()) {
5174 return ((myNPbase->mummZH(sqrt_s)) + (myNPbase->BrHgagaRatio()) - 1.0);
5175 } else {
5176 return (myNPbase->mummZH(sqrt_s))*(myNPbase->BrHgagaRatio());
5177 }
5178}
5179
5180mummZHmumu::mummZHmumu(const StandardModel& SM_i, const double sqrt_s_i)
5181: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5182{
5183 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5184 throw std::runtime_error("mummZHmumu called with a class whose parent is not NPbase");
5185}
5186
5188{
5189 if ((this->getModel()).isModelLinearized()) {
5190 return ((myNPbase->mummZH(sqrt_s)) + (myNPbase->BrHmumuRatio()) - 1.0);
5191 } else {
5192 return (myNPbase->mummZH(sqrt_s))*(myNPbase->BrHmumuRatio());
5193 }
5194}
5195
5196
5197
5198mummHvvbb::mummHvvbb(const StandardModel& SM_i, const double sqrt_s_i)
5199: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5200{
5201 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5202 throw std::runtime_error("mummHvvbb called with a class whose parent is not NPbase");
5203}
5204
5206{
5207 if ((this->getModel()).isModelLinearized()) {
5208 return ((myNPbase->mummHvv(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
5209 } else {
5210 return (myNPbase->mummHvv(sqrt_s))*(myNPbase->BrHbbRatio());
5211 }
5212}
5213
5214mummHvvcc::mummHvvcc(const StandardModel& SM_i, const double sqrt_s_i)
5215: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5216{
5217 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5218 throw std::runtime_error("mummHvvcc called with a class whose parent is not NPbase");
5219}
5220
5222{
5223 if ((this->getModel()).isModelLinearized()) {
5224 return ((myNPbase->mummHvv(sqrt_s)) + (myNPbase->BrHccRatio()) - 1.0);
5225 } else {
5226 return (myNPbase->mummHvv(sqrt_s))*(myNPbase->BrHccRatio());
5227 }
5228}
5229
5230mummHvvgg::mummHvvgg(const StandardModel& SM_i, const double sqrt_s_i)
5231: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5232{
5233 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5234 throw std::runtime_error("mummHvvgg called with a class whose parent is not NPbase");
5235}
5236
5238{
5239 if ((this->getModel()).isModelLinearized()) {
5240 return ((myNPbase->mummHvv(sqrt_s)) + (myNPbase->BrHggRatio()) - 1.0);
5241 } else {
5242 return (myNPbase->mummHvv(sqrt_s))*(myNPbase->BrHggRatio());
5243 }
5244}
5245
5246mummHvvWW::mummHvvWW(const StandardModel& SM_i, const double sqrt_s_i)
5247: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5248{
5249 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5250 throw std::runtime_error("mummHvvcc called with a class whose parent is not NPbase");
5251}
5252
5254{
5255 if ((this->getModel()).isModelLinearized()) {
5256 return ((myNPbase->mummHvv(sqrt_s)) + (myNPbase->BrHWWRatio()) - 1.0);
5257 } else {
5258 return (myNPbase->mummHvv(sqrt_s))*(myNPbase->BrHWWRatio());
5259 }
5260}
5261
5262mummHvvtautau::mummHvvtautau(const StandardModel& SM_i, const double sqrt_s_i)
5263: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5264{
5265 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5266 throw std::runtime_error("mummHvvtautau called with a class whose parent is not NPbase");
5267}
5268
5270{
5271 if ((this->getModel()).isModelLinearized()) {
5272 return ((myNPbase->mummHvv(sqrt_s)) + (myNPbase->BrHtautauRatio()) - 1.0);
5273 } else {
5275 }
5276}
5277
5278mummHvvZZ::mummHvvZZ(const StandardModel& SM_i, const double sqrt_s_i)
5279: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5280{
5281 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5282 throw std::runtime_error("mummHvvZZ called with a class whose parent is not NPbase");
5283}
5284
5286{
5287 if ((this->getModel()).isModelLinearized()) {
5288 return ((myNPbase->mummHvv(sqrt_s)) + (myNPbase->BrHZZRatio()) - 1.0);
5289 } else {
5290 return (myNPbase->mummHvv(sqrt_s))*(myNPbase->BrHZZRatio());
5291 }
5292}
5293
5294mummHvvZga::mummHvvZga(const StandardModel& SM_i, const double sqrt_s_i)
5295: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5296{
5297 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5298 throw std::runtime_error("mummHvvZga called with a class whose parent is not NPbase");
5299}
5300
5302{
5303 if ((this->getModel()).isModelLinearized()) {
5304 return ((myNPbase->mummHvv(sqrt_s)) + (myNPbase->BrHZgaRatio()) - 1.0);
5305 } else {
5306 return (myNPbase->mummHvv(sqrt_s))*(myNPbase->BrHZgaRatio());
5307 }
5308}
5309
5310mummHvvgaga::mummHvvgaga(const StandardModel& SM_i, const double sqrt_s_i)
5311: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5312{
5313 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5314 throw std::runtime_error("mummHvvgaga called with a class whose parent is not NPbase");
5315}
5316
5318{
5319 if ((this->getModel()).isModelLinearized()) {
5320 return ((myNPbase->mummHvv(sqrt_s)) + (myNPbase->BrHgagaRatio()) - 1.0);
5321 } else {
5323 }
5324}
5325
5326mummHvvmumu::mummHvvmumu(const StandardModel& SM_i, const double sqrt_s_i)
5327: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5328{
5329 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5330 throw std::runtime_error("mummHvvmumu called with a class whose parent is not NPbase");
5331}
5332
5334{
5335 if ((this->getModel()).isModelLinearized()) {
5336 return ((myNPbase->mummHvv(sqrt_s)) + (myNPbase->BrHmumuRatio()) - 1.0);
5337 } else {
5339 }
5340}
5341
5342
5343
5344mummHmmbb::mummHmmbb(const StandardModel& SM_i, const double sqrt_s_i)
5345: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5346{
5347 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5348 throw std::runtime_error("mummHmmbb called with a class whose parent is not NPbase");
5349}
5350
5352{
5353 if ((this->getModel()).isModelLinearized()) {
5354 return ((myNPbase->mummHmm(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
5355 } else {
5356 return (myNPbase->mummHmm(sqrt_s))*(myNPbase->BrHbbRatio());
5357 }
5358}
5359
5360mummHmmcc::mummHmmcc(const StandardModel& SM_i, const double sqrt_s_i)
5361: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5362{
5363 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5364 throw std::runtime_error("mummHmmcc called with a class whose parent is not NPbase");
5365}
5366
5368{
5369 if ((this->getModel()).isModelLinearized()) {
5370 return ((myNPbase->mummHmm(sqrt_s)) + (myNPbase->BrHccRatio()) - 1.0);
5371 } else {
5372 return (myNPbase->mummHmm(sqrt_s))*(myNPbase->BrHccRatio());
5373 }
5374}
5375
5376mummHmmgg::mummHmmgg(const StandardModel& SM_i, const double sqrt_s_i)
5377: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5378{
5379 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5380 throw std::runtime_error("mummHmmgg called with a class whose parent is not NPbase");
5381}
5382
5384{
5385 if ((this->getModel()).isModelLinearized()) {
5386 return ((myNPbase->mummHmm(sqrt_s)) + (myNPbase->BrHggRatio()) - 1.0);
5387 } else {
5388 return (myNPbase->mummHmm(sqrt_s))*(myNPbase->BrHggRatio());
5389 }
5390}
5391
5392mummHmmWW::mummHmmWW(const StandardModel& SM_i, const double sqrt_s_i)
5393: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5394{
5395 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5396 throw std::runtime_error("mummHmmcc called with a class whose parent is not NPbase");
5397}
5398
5400{
5401 if ((this->getModel()).isModelLinearized()) {
5402 return ((myNPbase->mummHmm(sqrt_s)) + (myNPbase->BrHWWRatio()) - 1.0);
5403 } else {
5404 return (myNPbase->mummHmm(sqrt_s))*(myNPbase->BrHWWRatio());
5405 }
5406}
5407
5408mummHmmtautau::mummHmmtautau(const StandardModel& SM_i, const double sqrt_s_i)
5409: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5410{
5411 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5412 throw std::runtime_error("mummHmmtautau called with a class whose parent is not NPbase");
5413}
5414
5416{
5417 if ((this->getModel()).isModelLinearized()) {
5418 return ((myNPbase->mummHmm(sqrt_s)) + (myNPbase->BrHtautauRatio()) - 1.0);
5419 } else {
5421 }
5422}
5423
5424mummHmmZZ::mummHmmZZ(const StandardModel& SM_i, const double sqrt_s_i)
5425: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5426{
5427 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5428 throw std::runtime_error("mummHmmZZ called with a class whose parent is not NPbase");
5429}
5430
5432{
5433 if ((this->getModel()).isModelLinearized()) {
5434 return ((myNPbase->mummHmm(sqrt_s)) + (myNPbase->BrHZZRatio()) - 1.0);
5435 } else {
5436 return (myNPbase->mummHmm(sqrt_s))*(myNPbase->BrHZZRatio());
5437 }
5438}
5439
5440mummHmmZga::mummHmmZga(const StandardModel& SM_i, const double sqrt_s_i)
5441: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5442{
5443 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5444 throw std::runtime_error("mummHmmZga called with a class whose parent is not NPbase");
5445}
5446
5448{
5449 if ((this->getModel()).isModelLinearized()) {
5450 return ((myNPbase->mummHmm(sqrt_s)) + (myNPbase->BrHZgaRatio()) - 1.0);
5451 } else {
5452 return (myNPbase->mummHmm(sqrt_s))*(myNPbase->BrHZgaRatio());
5453 }
5454}
5455
5456mummHmmgaga::mummHmmgaga(const StandardModel& SM_i, const double sqrt_s_i)
5457: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5458{
5459 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5460 throw std::runtime_error("mummHmmgaga called with a class whose parent is not NPbase");
5461}
5462
5464{
5465 if ((this->getModel()).isModelLinearized()) {
5466 return ((myNPbase->mummHmm(sqrt_s)) + (myNPbase->BrHgagaRatio()) - 1.0);
5467 } else {
5469 }
5470}
5471
5472mummHmmmumu::mummHmmmumu(const StandardModel& SM_i, const double sqrt_s_i)
5473: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5474{
5475 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5476 throw std::runtime_error("mummHmmmumu called with a class whose parent is not NPbase");
5477}
5478
5480{
5481 if ((this->getModel()).isModelLinearized()) {
5482 return ((myNPbase->mummHmm(sqrt_s)) + (myNPbase->BrHmumuRatio()) - 1.0);
5483 } else {
5485 }
5486}
5487
5488
5489mummttHbb::mummttHbb(const StandardModel& SM_i, const double sqrt_s_i)
5490: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5491{
5492 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5493 throw std::runtime_error("mummttHbb called with a class whose parent is not NPbase");
5494}
5495
5497{
5498 if ((this->getModel()).isModelLinearized()) {
5499 return ((myNPbase->mummttH(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
5500 } else {
5501 return (myNPbase->mummttH(sqrt_s))*(myNPbase->BrHbbRatio());
5502 }
5503}
5504
5505mummttHcc::mummttHcc(const StandardModel& SM_i, const double sqrt_s_i)
5506: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5507{
5508 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5509 throw std::runtime_error("mummttHcc called with a class whose parent is not NPbase");
5510}
5511
5513{
5514 if ((this->getModel()).isModelLinearized()) {
5515 return ((myNPbase->mummttH(sqrt_s)) + (myNPbase->BrHccRatio()) - 1.0);
5516 } else {
5517 return (myNPbase->mummttH(sqrt_s))*(myNPbase->BrHccRatio());
5518 }
5519}
5520
5521mummttHgg::mummttHgg(const StandardModel& SM_i, const double sqrt_s_i)
5522: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5523{
5524 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5525 throw std::runtime_error("mummttHgg called with a class whose parent is not NPbase");
5526}
5527
5529{
5530 if ((this->getModel()).isModelLinearized()) {
5531 return ((myNPbase->mummttH(sqrt_s)) + (myNPbase->BrHggRatio()) - 1.0);
5532 } else {
5533 return (myNPbase->mummttH(sqrt_s))*(myNPbase->BrHggRatio());
5534 }
5535}
5536
5537mummttHWW::mummttHWW(const StandardModel& SM_i, const double sqrt_s_i)
5538: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5539{
5540 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5541 throw std::runtime_error("mummttHcc called with a class whose parent is not NPbase");
5542}
5543
5545{
5546 if ((this->getModel()).isModelLinearized()) {
5547 return ((myNPbase->mummttH(sqrt_s)) + (myNPbase->BrHWWRatio()) - 1.0);
5548 } else {
5549 return (myNPbase->mummttH(sqrt_s))*(myNPbase->BrHWWRatio());
5550 }
5551}
5552
5553mummttHtautau::mummttHtautau(const StandardModel& SM_i, const double sqrt_s_i)
5554: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5555{
5556 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5557 throw std::runtime_error("mummttHtautau called with a class whose parent is not NPbase");
5558}
5559
5561{
5562 if ((this->getModel()).isModelLinearized()) {
5563 return ((myNPbase->mummttH(sqrt_s)) + (myNPbase->BrHtautauRatio()) - 1.0);
5564 } else {
5566 }
5567}
5568
5569mummttHZZ::mummttHZZ(const StandardModel& SM_i, const double sqrt_s_i)
5570: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5571{
5572 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5573 throw std::runtime_error("mummttHZZ called with a class whose parent is not NPbase");
5574}
5575
5577{
5578 if ((this->getModel()).isModelLinearized()) {
5579 return ((myNPbase->mummttH(sqrt_s)) + (myNPbase->BrHZZRatio()) - 1.0);
5580 } else {
5581 return (myNPbase->mummttH(sqrt_s))*(myNPbase->BrHZZRatio());
5582 }
5583}
5584
5585mummttHZga::mummttHZga(const StandardModel& SM_i, const double sqrt_s_i)
5586: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5587{
5588 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5589 throw std::runtime_error("mummttHZga called with a class whose parent is not NPbase");
5590}
5591
5593{
5594 if ((this->getModel()).isModelLinearized()) {
5595 return ((myNPbase->mummttH(sqrt_s)) + (myNPbase->BrHZgaRatio()) - 1.0);
5596 } else {
5597 return (myNPbase->mummttH(sqrt_s))*(myNPbase->BrHZgaRatio());
5598 }
5599}
5600
5601mummttHgaga::mummttHgaga(const StandardModel& SM_i, const double sqrt_s_i)
5602: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5603{
5604 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5605 throw std::runtime_error("mummttHgaga called with a class whose parent is not NPbase");
5606}
5607
5609{
5610 if ((this->getModel()).isModelLinearized()) {
5611 return ((myNPbase->mummttH(sqrt_s)) + (myNPbase->BrHgagaRatio()) - 1.0);
5612 } else {
5614 }
5615}
5616
5617mummttHmumu::mummttHmumu(const StandardModel& SM_i, const double sqrt_s_i)
5618: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5619{
5620 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5621 throw std::runtime_error("mummttHmumu called with a class whose parent is not NPbase");
5622}
5623
5625{
5626 if ((this->getModel()).isModelLinearized()) {
5627 return ((myNPbase->mummttH(sqrt_s)) + (myNPbase->BrHmumuRatio()) - 1.0);
5628 } else {
5630 }
5631}
5632
5633
5634// The same in the narrow width approximation
5635
5636mummHbbNWA::mummHbbNWA(const StandardModel& SM_i, const double sqrt_s_i)
5637: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5638{
5639 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5640 throw std::runtime_error("mummHbbNWA called with a class whose parent is not NPbase");
5641}
5642
5644{
5645 if ((this->getModel()).isModelLinearized()) {
5646 return ((myNPbase->mummHNWA(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
5647 } else {
5648 return (myNPbase->mummHNWA(sqrt_s))*(myNPbase->BrHbbRatio());
5649 }
5650}
5651
5652mummHccNWA::mummHccNWA(const StandardModel& SM_i, const double sqrt_s_i)
5653: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5654{
5655 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5656 throw std::runtime_error("mummHccNWA called with a class whose parent is not NPbase");
5657}
5658
5660{
5661 if ((this->getModel()).isModelLinearized()) {
5662 return ((myNPbase->mummHNWA(sqrt_s)) + (myNPbase->BrHccRatio()) - 1.0);
5663 } else {
5664 return (myNPbase->mummHNWA(sqrt_s))*(myNPbase->BrHccRatio());
5665 }
5666}
5667
5668mummHggNWA::mummHggNWA(const StandardModel& SM_i, const double sqrt_s_i)
5669: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5670{
5671 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5672 throw std::runtime_error("mummHggNWA called with a class whose parent is not NPbase");
5673}
5674
5676{
5677 if ((this->getModel()).isModelLinearized()) {
5678 return ((myNPbase->mummHNWA(sqrt_s)) + (myNPbase->BrHggRatio()) - 1.0);
5679 } else {
5680 return (myNPbase->mummHNWA(sqrt_s))*(myNPbase->BrHggRatio());
5681 }
5682}
5683
5684mummHWWNWA::mummHWWNWA(const StandardModel& SM_i, const double sqrt_s_i)
5685: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5686{
5687 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5688 throw std::runtime_error("mummHccNWA called with a class whose parent is not NPbase");
5689}
5690
5692{
5693 if ((this->getModel()).isModelLinearized()) {
5694 return ((myNPbase->mummHNWA(sqrt_s)) + (myNPbase->BrHWWRatio()) - 1.0);
5695 } else {
5696 return (myNPbase->mummHNWA(sqrt_s))*(myNPbase->BrHWWRatio());
5697 }
5698}
5699
5700mummHtautauNWA::mummHtautauNWA(const StandardModel& SM_i, const double sqrt_s_i)
5701: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5702{
5703 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5704 throw std::runtime_error("mummHtautauNWA called with a class whose parent is not NPbase");
5705}
5706
5708{
5709 if ((this->getModel()).isModelLinearized()) {
5710 return ((myNPbase->mummHNWA(sqrt_s)) + (myNPbase->BrHtautauRatio()) - 1.0);
5711 } else {
5713 }
5714}
5715
5716mummHZZNWA::mummHZZNWA(const StandardModel& SM_i, const double sqrt_s_i)
5717: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5718{
5719 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5720 throw std::runtime_error("mummHZZNWA called with a class whose parent is not NPbase");
5721}
5722
5724{
5725 if ((this->getModel()).isModelLinearized()) {
5726 return ((myNPbase->mummHNWA(sqrt_s)) + (myNPbase->BrHZZRatio()) - 1.0);
5727 } else {
5728 return (myNPbase->mummHNWA(sqrt_s))*(myNPbase->BrHZZRatio());
5729 }
5730}
5731
5732mummHZgaNWA::mummHZgaNWA(const StandardModel& SM_i, const double sqrt_s_i)
5733: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5734{
5735 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5736 throw std::runtime_error("mummHZgaNWA called with a class whose parent is not NPbase");
5737}
5738
5740{
5741 if ((this->getModel()).isModelLinearized()) {
5742 return ((myNPbase->mummHNWA(sqrt_s)) + (myNPbase->BrHZgaRatio()) - 1.0);
5743 } else {
5745 }
5746}
5747
5748mummHgagaNWA::mummHgagaNWA(const StandardModel& SM_i, const double sqrt_s_i)
5749: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5750{
5751 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5752 throw std::runtime_error("mummHgagaNWA called with a class whose parent is not NPbase");
5753}
5754
5756{
5757 if ((this->getModel()).isModelLinearized()) {
5758 return ((myNPbase->mummHNWA(sqrt_s)) + (myNPbase->BrHgagaRatio()) - 1.0);
5759 } else {
5761 }
5762}
5763
5764mummHmumuNWA::mummHmumuNWA(const StandardModel& SM_i, const double sqrt_s_i)
5765: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5766{
5767 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5768 throw std::runtime_error("mummHmumuNWA called with a class whose parent is not NPbase");
5769}
5770
5772{
5773 if ((this->getModel()).isModelLinearized()) {
5774 return ((myNPbase->mummHNWA(sqrt_s)) + (myNPbase->BrHmumuRatio()) - 1.0);
5775 } else {
5777 }
5778}
5779
5780// Full signal strengths at ep colliders
5781// -------------------------------------
5782
5783muepWBFbb::muepWBFbb(const StandardModel& SM_i, const double sqrt_s_i)
5784: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5785{
5786 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5787 throw std::runtime_error("muepWBFbb called with a class whose parent is not NPbase");
5788
5789}
5790
5792{
5793 if ((this->getModel()).isModelLinearized()) {
5794 return ((myNPbase->muepWBF(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
5795 } else {
5796 return (myNPbase->muepWBF(sqrt_s))*(myNPbase->BrHbbRatio());
5797 }
5798}
5799
5800muepWBFcc::muepWBFcc(const StandardModel& SM_i, const double sqrt_s_i)
5801: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5802{
5803 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5804 throw std::runtime_error("muepWBFcc called with a class whose parent is not NPbase");
5805
5806}
5807
5809{
5810 if ((this->getModel()).isModelLinearized()) {
5811 return ((myNPbase->muepWBF(sqrt_s)) + (myNPbase->BrHccRatio()) - 1.0);
5812 } else {
5813 return (myNPbase->muepWBF(sqrt_s))*(myNPbase->BrHccRatio());
5814 }
5815}
5816
5817muepWBFgg::muepWBFgg(const StandardModel& SM_i, const double sqrt_s_i)
5818: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5819{
5820 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5821 throw std::runtime_error("muepWBFgg called with a class whose parent is not NPbase");
5822
5823}
5824
5826{
5827 if ((this->getModel()).isModelLinearized()) {
5828 return ((myNPbase->muepWBF(sqrt_s)) + (myNPbase->BrHggRatio()) - 1.0);
5829 } else {
5830 return (myNPbase->muepWBF(sqrt_s))*(myNPbase->BrHggRatio());
5831 }
5832}
5833
5834muepWBFWW2l2v::muepWBFWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
5835: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5836{
5837 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5838 throw std::runtime_error("muepWBFWW2l2v called with a class whose parent is not NPbase");
5839
5840}
5841
5843{
5844 if ((this->getModel()).isModelLinearized()) {
5845 return ((myNPbase->muepWBF(sqrt_s)) + (myNPbase->BrH2l2vRatio()) - 1.0);
5846 } else {
5848 }
5849}
5850
5851muepWBFZZ4l::muepWBFZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
5852: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5853{
5854 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5855 throw std::runtime_error("muepWBFZZ4l called with a class whose parent is not NPbase");
5856
5857}
5858
5860{
5861 if ((this->getModel()).isModelLinearized()) {
5862 return ((myNPbase->muepWBF(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
5863 } else {
5864 return (myNPbase->muepWBF(sqrt_s))*(myNPbase->BrH4lRatio());
5865 }
5866}
5867
5868muepWBFgaga::muepWBFgaga(const StandardModel& SM_i, const double sqrt_s_i)
5869: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5870{
5871 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5872 throw std::runtime_error("muepWBFgaga called with a class whose parent is not NPbase");
5873
5874}
5875
5877{
5878 if ((this->getModel()).isModelLinearized()) {
5879 return ((myNPbase->muepWBF(sqrt_s)) + (myNPbase->BrHgagaRatio()) - 1.0);
5880 } else {
5882 }
5883}
5884
5885muepWBFtautau::muepWBFtautau(const StandardModel& SM_i, const double sqrt_s_i)
5886: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5887{
5888 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5889 throw std::runtime_error("muepWBFtautau called with a class whose parent is not NPbase");
5890
5891}
5892
5894{
5895 if ((this->getModel()).isModelLinearized()) {
5896 return ((myNPbase->muepWBF(sqrt_s)) + (myNPbase->BrHtautauRatio()) - 1.0);
5897 } else {
5899 }
5900}
5901
5902muepZBFbb::muepZBFbb(const StandardModel& SM_i, const double sqrt_s_i)
5903: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5904{
5905 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5906 throw std::runtime_error("muepZBFbb called with a class whose parent is not NPbase");
5907
5908}
5909
5911{
5912 if ((this->getModel()).isModelLinearized()) {
5913 return ((myNPbase->muepZBF(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
5914 } else {
5915 return (myNPbase->muepZBF(sqrt_s))*(myNPbase->BrHbbRatio());
5916 }
5917}
5918
5919muepZBFcc::muepZBFcc(const StandardModel& SM_i, const double sqrt_s_i)
5920: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5921{
5922 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5923 throw std::runtime_error("muepZBFcc called with a class whose parent is not NPbase");
5924
5925}
5926
5928{
5929 if ((this->getModel()).isModelLinearized()) {
5930 return ((myNPbase->muepZBF(sqrt_s)) + (myNPbase->BrHccRatio()) - 1.0);
5931 } else {
5932 return (myNPbase->muepZBF(sqrt_s))*(myNPbase->BrHccRatio());
5933 }
5934}
5935
5936muepZBFgg::muepZBFgg(const StandardModel& SM_i, const double sqrt_s_i)
5937: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5938{
5939 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5940 throw std::runtime_error("muepZBFgg called with a class whose parent is not NPbase");
5941
5942}
5943
5945{
5946 if ((this->getModel()).isModelLinearized()) {
5947 return ((myNPbase->muepZBF(sqrt_s)) + (myNPbase->BrHggRatio()) - 1.0);
5948 } else {
5949 return (myNPbase->muepZBF(sqrt_s))*(myNPbase->BrHggRatio());
5950 }
5951}
5952
5953muepZBFWW2l2v::muepZBFWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
5954: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5955{
5956 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5957 throw std::runtime_error("muepZBFWW2l2v called with a class whose parent is not NPbase");
5958
5959}
5960
5962{
5963 if ((this->getModel()).isModelLinearized()) {
5964 return ((myNPbase->muepZBF(sqrt_s)) + (myNPbase->BrH2l2vRatio()) - 1.0);
5965 } else {
5967 }
5968}
5969
5970muepZBFZZ4l::muepZBFZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
5971: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5972{
5973 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5974 throw std::runtime_error("muepZBFZZ4l called with a class whose parent is not NPbase");
5975
5976}
5977
5979{
5980 if ((this->getModel()).isModelLinearized()) {
5981 return ((myNPbase->muepZBF(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
5982 } else {
5983 return (myNPbase->muepZBF(sqrt_s))*(myNPbase->BrH4lRatio());
5984 }
5985}
5986
5987muepZBFgaga::muepZBFgaga(const StandardModel& SM_i, const double sqrt_s_i)
5988: ThObservable(SM_i), sqrt_s(sqrt_s_i)
5989{
5990 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
5991 throw std::runtime_error("muepZBFgaga called with a class whose parent is not NPbase");
5992
5993}
5994
5996{
5997 if ((this->getModel()).isModelLinearized()) {
5998 return ((myNPbase->muepZBF(sqrt_s)) + (myNPbase->BrHgagaRatio()) - 1.0);
5999 } else {
6001 }
6002}
6003
6004muepZBFtautau::muepZBFtautau(const StandardModel& SM_i, const double sqrt_s_i)
6005: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6006{
6007 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6008 throw std::runtime_error("muepZBFtautau called with a class whose parent is not NPbase");
6009
6010}
6011
6013{
6014 if ((this->getModel()).isModelLinearized()) {
6015 return ((myNPbase->muepZBF(sqrt_s)) + (myNPbase->BrHtautauRatio()) - 1.0);
6016 } else {
6018 }
6019}
6020
6021
6022// -----------------------------------------------------------------------------
6023// STXS bins
6024// -----------------------------------------------------------------------------
6025
6026// -----------------------------------------------------------------------------
6027// Stage 0
6028// -----------------------------------------------------------------------------
6029
6030STXS_0_qqH::STXS_0_qqH(const StandardModel& SM_i, const double sqrt_s_i)
6031: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6032{
6033 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6034 throw std::runtime_error("STXS_0_qqH called with a class whose parent is not NPbase");
6035
6036}
6037
6039{
6040 return myNPbase->STXS0_qqH(sqrt_s);
6041}
6042
6043
6044// -----------------------------------------------------------------------------
6045// Stage 1
6046// -----------------------------------------------------------------------------
6047
6049: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6050{
6051 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6052 throw std::runtime_error("STXSggH_VBFtopo_j3v_4l called with a class whose parent is not NPbase");
6053
6054}
6055
6057{
6058 if ((this->getModel()).isModelLinearized()) {
6059 return ((myNPbase->STXS_ggH_VBFtopo_j3v(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6060 } else {
6062 }
6063}
6064
6065
6067: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6068{
6069 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6070 throw std::runtime_error("STXSggH_VBFtopo_j3_4l called with a class whose parent is not NPbase");
6071
6072}
6073
6075{
6076 if ((this->getModel()).isModelLinearized()) {
6077 return ((myNPbase->STXS_ggH_VBFtopo_j3(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6078 } else {
6080 }
6081}
6082
6083
6084STXSggH0j4l::STXSggH0j4l(const StandardModel& SM_i, const double sqrt_s_i)
6085: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6086{
6087 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6088 throw std::runtime_error("STXSggH0j4l called with a class whose parent is not NPbase");
6089
6090}
6091
6093{
6094 if ((this->getModel()).isModelLinearized()) {
6095 return ((myNPbase->STXS_ggH0j(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6096 } else {
6098 }
6099}
6100
6102: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6103{
6104 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6105 throw std::runtime_error("STXSggH1j_pTH_0_60_4l called with a class whose parent is not NPbase");
6106
6107}
6108
6110{
6111 if ((this->getModel()).isModelLinearized()) {
6112 return ((myNPbase->STXS_ggH1j_pTH_0_60(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6113 } else {
6115 }
6116}
6117
6119: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6120{
6121 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6122 throw std::runtime_error("STXSggH1j_pTH_60_120_4l called with a class whose parent is not NPbase");
6123
6124}
6125
6127{
6128 if ((this->getModel()).isModelLinearized()) {
6129 return ((myNPbase->STXS_ggH1j_pTH_60_120(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6130 } else {
6132 }
6133}
6134
6136: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6137{
6138 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6139 throw std::runtime_error("STXSggH1j_pTH_120_200_4l called with a class whose parent is not NPbase");
6140
6141}
6142
6144{
6145 if ((this->getModel()).isModelLinearized()) {
6146 return ((myNPbase->STXS_ggH1j_pTH_120_200(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6147 } else {
6149 }
6150}
6151
6153: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6154{
6155 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6156 throw std::runtime_error("STXSggH1j_pTH_200_4l called with a class whose parent is not NPbase");
6157
6158}
6159
6161{
6162 if ((this->getModel()).isModelLinearized()) {
6163 return ((myNPbase->STXS_ggH1j_pTH_200(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6164 } else {
6166 }
6167}
6168
6170: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6171{
6172 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6173 throw std::runtime_error("STXSggH2j_pTH_0_200_4l called with a class whose parent is not NPbase");
6174
6175}
6176
6178{
6179 if ((this->getModel()).isModelLinearized()) {
6180 return ((myNPbase->STXS_ggH2j_pTH_0_200(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6181 } else {
6183 }
6184}
6185
6186
6188: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6189{
6190 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6191 throw std::runtime_error("STXSggH2j_pTH_0_60_4l called with a class whose parent is not NPbase");
6192
6193}
6194
6196{
6197 if ((this->getModel()).isModelLinearized()) {
6198 return ((myNPbase->STXS_ggH2j_pTH_0_60(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6199 } else {
6201 }
6202}
6203
6204
6206: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6207{
6208 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6209 throw std::runtime_error("STXSggH2j_pTH_60_120_4l called with a class whose parent is not NPbase");
6210
6211}
6212
6214{
6215 if ((this->getModel()).isModelLinearized()) {
6216 return ((myNPbase->STXS_ggH2j_pTH_60_120(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6217 } else {
6219 }
6220}
6221
6222
6224: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6225{
6226 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6227 throw std::runtime_error("STXSggH2j_pTH_120_200_4l called with a class whose parent is not NPbase");
6228
6229}
6230
6232{
6233 if ((this->getModel()).isModelLinearized()) {
6234 return ((myNPbase->STXS_ggH2j_pTH_120_200(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6235 } else {
6237 }
6238}
6239
6240
6242: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6243{
6244 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6245 throw std::runtime_error("STXSggH2j_pTH_200_4l called with a class whose parent is not NPbase");
6246
6247}
6248
6250{
6251 if ((this->getModel()).isModelLinearized()) {
6252 return ((myNPbase->STXS_ggH2j_pTH_200(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6253 } else {
6255 }
6256}
6257
6258
6260: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6261{
6262 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6263 throw std::runtime_error("STXSqqHqq_VBFtopo_Rest_4l called with a class whose parent is not NPbase");
6264
6265}
6266
6268{
6269 if ((this->getModel()).isModelLinearized()) {
6270 return ((myNPbase->STXS_qqHqq_VBFtopo_Rest(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6271 } else {
6273 }
6274}
6275
6276
6278: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6279{
6280 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6281 throw std::runtime_error("STXSqqHqq_VBFtopo_j3v_4l called with a class whose parent is not NPbase");
6282
6283}
6284
6286{
6287 if ((this->getModel()).isModelLinearized()) {
6288 return ((myNPbase->STXS_qqHqq_VBFtopo_j3v(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6289 } else {
6291 }
6292}
6293
6294
6295
6297: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6298{
6299 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6300 throw std::runtime_error("STXSqqHqq_VBFtopo_j3_4l called with a class whose parent is not NPbase");
6301
6302}
6303
6305{
6306 if ((this->getModel()).isModelLinearized()) {
6307 return ((myNPbase->STXS_qqHqq_VBFtopo_j3(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6308 } else {
6310 }
6311}
6312
6313
6314
6316: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6317{
6318 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6319 throw std::runtime_error("STXSqqHqq_nonVHtopo_4l called with a class whose parent is not NPbase");
6320
6321}
6322
6324{
6325 if ((this->getModel()).isModelLinearized()) {
6326 return ((myNPbase->STXS_qqHqq_nonVHtopo(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6327 } else {
6329 }
6330}
6331
6332
6333
6335: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6336{
6337 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6338 throw std::runtime_error("STXSqqHqq_VHtopo_4l called with a class whose parent is not NPbase");
6339
6340}
6341
6343{
6344 if ((this->getModel()).isModelLinearized()) {
6345 return ((myNPbase->STXS_qqHqq_VHtopo(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6346 } else {
6348 }
6349}
6350
6351
6352STXSqqHqq_Rest_4l::STXSqqHqq_Rest_4l(const StandardModel& SM_i, const double sqrt_s_i)
6353: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6354{
6355 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6356 throw std::runtime_error("STXSqqHqq_Rest_4l called with a class whose parent is not NPbase");
6357
6358}
6359
6361{
6362 if ((this->getModel()).isModelLinearized()) {
6363 return ((myNPbase->STXS_qqHqq_Rest(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6364 } else {
6366 }
6367}
6368
6369
6371: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6372{
6373 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6374 throw std::runtime_error("STXSqqHqq_pTj_200_4l called with a class whose parent is not NPbase");
6375
6376}
6377
6379{
6380 if ((this->getModel()).isModelLinearized()) {
6381 return ((myNPbase->STXS_qqHqq_pTj_200(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6382 } else {
6384 }
6385}
6386
6388: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6389{
6390 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6391 throw std::runtime_error("STXSqqHlv_pTV_0_250_4l called with a class whose parent is not NPbase");
6392
6393}
6394
6396{
6397 if ((this->getModel()).isModelLinearized()) {
6398 return ((myNPbase->STXS_qqHlv_pTV_0_250(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6399 } else {
6401 }
6402}
6403
6404
6406: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6407{
6408 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6409 throw std::runtime_error("STXSqqHlv_pTV_0_150_4l called with a class whose parent is not NPbase");
6410
6411}
6412
6414{
6415 if ((this->getModel()).isModelLinearized()) {
6416 return ((myNPbase->STXS_qqHlv_pTV_0_150(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6417 } else {
6419 }
6420}
6421
6422
6423
6425: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6426{
6427 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6428 throw std::runtime_error("STXSqqHlv_pTV_150_250_0j_4l called with a class whose parent is not NPbase");
6429
6430}
6431
6433{
6434 if ((this->getModel()).isModelLinearized()) {
6436 } else {
6438 }
6439}
6440
6441
6442
6444: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6445{
6446 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6447 throw std::runtime_error("STXSqqHlv_pTV_150_250_1j_4l called with a class whose parent is not NPbase");
6448
6449}
6450
6452{
6453 if ((this->getModel()).isModelLinearized()) {
6455 } else {
6457 }
6458}
6459
6460
6462: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6463{
6464 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6465 throw std::runtime_error("STXSqqHlv_pTV_250_4l called with a class whose parent is not NPbase");
6466
6467}
6468
6470{
6471 if ((this->getModel()).isModelLinearized()) {
6472 return ((myNPbase->STXS_qqHlv_pTV_250(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6473 } else {
6475 }
6476}
6477
6479: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6480{
6481 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6482 throw std::runtime_error("STXSqqHll_pTV_0_150_4l called with a class whose parent is not NPbase");
6483
6484}
6485
6487{
6488 if ((this->getModel()).isModelLinearized()) {
6489 return ((myNPbase->STXS_qqHll_pTV_0_150(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6490 } else {
6492 }
6493}
6494
6496: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6497{
6498 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6499 throw std::runtime_error("STXSqqHll_pTV_150_250_4l called with a class whose parent is not NPbase");
6500
6501}
6502
6504{
6505 if ((this->getModel()).isModelLinearized()) {
6506 return ((myNPbase->STXS_qqHll_pTV_150_250(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6507 } else {
6509 }
6510}
6511
6512
6514: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6515{
6516 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6517 throw std::runtime_error("STXSqqHll_pTV_150_250_0j_4l called with a class whose parent is not NPbase");
6518
6519}
6520
6522{
6523 if ((this->getModel()).isModelLinearized()) {
6525 } else {
6527 }
6528}
6529
6530
6532: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6533{
6534 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6535 throw std::runtime_error("STXSqqHll_pTV_150_250_1j_4l called with a class whose parent is not NPbase");
6536
6537}
6538
6540{
6541 if ((this->getModel()).isModelLinearized()) {
6543 } else {
6545 }
6546}
6547
6548
6550: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6551{
6552 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6553 throw std::runtime_error("STXSqqHll_pTV_250_4l called with a class whose parent is not NPbase");
6554
6555}
6556
6558{
6559 if ((this->getModel()).isModelLinearized()) {
6560 return ((myNPbase->STXS_qqHll_pTV_250(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6561 } else {
6563 }
6564}
6565
6566STXSttHtH4l::STXSttHtH4l(const StandardModel& SM_i, const double sqrt_s_i)
6567: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6568{
6569 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6570 throw std::runtime_error("STXSttHtH4l called with a class whose parent is not NPbase");
6571
6572}
6573
6575{
6576 if ((this->getModel()).isModelLinearized()) {
6577 return ((myNPbase->STXS_ttHtH(sqrt_s)) + (myNPbase->BrH4lRatio()) - 1.0);
6578 } else {
6580 }
6581}
6582
6583
6585: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6586{
6587 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6588 throw std::runtime_error("STXSqqHlv_pTV_0_250_bb called with a class whose parent is not NPbase");
6589
6590}
6591
6593{
6594 if ((this->getModel()).isModelLinearized()) {
6595 return ((myNPbase->STXS_qqHlv_pTV_0_250(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
6596 } else {
6598 }
6599}
6600
6601
6603: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6604{
6605 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6606 throw std::runtime_error("STXSqqHlv_pTV_0_150_bb called with a class whose parent is not NPbase");
6607
6608}
6609
6611{
6612 if ((this->getModel()).isModelLinearized()) {
6613 return ((myNPbase->STXS_qqHlv_pTV_0_150(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
6614 } else {
6616 }
6617}
6618
6619
6620
6622: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6623{
6624 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6625 throw std::runtime_error("STXSqqHlv_pTV_150_250_0j_bb called with a class whose parent is not NPbase");
6626
6627}
6628
6630{
6631 if ((this->getModel()).isModelLinearized()) {
6633 } else {
6635 }
6636}
6637
6638
6639
6641: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6642{
6643 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6644 throw std::runtime_error("STXSqqHlv_pTV_150_250_1j_bb called with a class whose parent is not NPbase");
6645
6646}
6647
6649{
6650 if ((this->getModel()).isModelLinearized()) {
6652 } else {
6654 }
6655}
6656
6657
6659: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6660{
6661 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6662 throw std::runtime_error("STXSqqHlv_pTV_250_bb called with a class whose parent is not NPbase");
6663
6664}
6665
6667{
6668 if ((this->getModel()).isModelLinearized()) {
6669 return ((myNPbase->STXS_qqHlv_pTV_250(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
6670 } else {
6672 }
6673}
6674
6676: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6677{
6678 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6679 throw std::runtime_error("STXSqqHll_pTV_0_150_bb called with a class whose parent is not NPbase");
6680
6681}
6682
6684{
6685 if ((this->getModel()).isModelLinearized()) {
6686 return ((myNPbase->STXS_qqHll_pTV_0_150(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
6687 } else {
6689 }
6690}
6691
6693: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6694{
6695 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6696 throw std::runtime_error("STXSqqHll_pTV_150_250_bb called with a class whose parent is not NPbase");
6697
6698}
6699
6701{
6702 if ((this->getModel()).isModelLinearized()) {
6703 return ((myNPbase->STXS_qqHll_pTV_150_250(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
6704 } else {
6706 }
6707}
6708
6709
6711: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6712{
6713 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6714 throw std::runtime_error("STXSqqHll_pTV_150_250_0j_bb called with a class whose parent is not NPbase");
6715
6716}
6717
6719{
6720 if ((this->getModel()).isModelLinearized()) {
6722 } else {
6724 }
6725}
6726
6727
6729: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6730{
6731 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6732 throw std::runtime_error("STXSqqHll_pTV_150_250_1j_bb called with a class whose parent is not NPbase");
6733
6734}
6735
6737{
6738 if ((this->getModel()).isModelLinearized()) {
6740 } else {
6742 }
6743}
6744
6745
6747: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6748{
6749 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6750 throw std::runtime_error("STXSqqHll_pTV_250_bb called with a class whose parent is not NPbase");
6751
6752}
6753
6755{
6756 if ((this->getModel()).isModelLinearized()) {
6757 return ((myNPbase->STXS_qqHll_pTV_250(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
6758 } else {
6760 }
6761}
6762
6763
6765: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6766{
6767 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6768 throw std::runtime_error("STXSWHqqHqq_VBFtopo_j3v_2b called with a class whose parent is not NPbase");
6769
6770}
6771
6773{
6774 if ((this->getModel()).isModelLinearized()) {
6776 } else {
6778 }
6779}
6780
6781
6783: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6784{
6785 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6786 throw std::runtime_error("STXSWHqqHqq_VBFtopo_j3_2b called with a class whose parent is not NPbase");
6787
6788}
6789
6791{
6792 if ((this->getModel()).isModelLinearized()) {
6793 return ((myNPbase->STXS_WHqqHqq_VBFtopo_j3(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
6794 } else {
6796 }
6797}
6798
6799
6801: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6802{
6803 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6804 throw std::runtime_error("STXSWHqqHqq_VH2j_2b called with a class whose parent is not NPbase");
6805
6806}
6807
6809{
6810 if ((this->getModel()).isModelLinearized()) {
6811 return ((myNPbase->STXS_WHqqHqq_VH2j(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
6812 } else {
6814 }
6815}
6816
6817
6819: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6820{
6821 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6822 throw std::runtime_error("STXSWHqqHqq_Rest_2b called with a class whose parent is not NPbase");
6823
6824}
6825
6827{
6828 if ((this->getModel()).isModelLinearized()) {
6829 return ((myNPbase->STXS_WHqqHqq_Rest(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
6830 } else {
6832 }
6833}
6834
6835
6837: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6838{
6839 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6840 throw std::runtime_error("STXSWHqqHqq_pTj1_200_2b called with a class whose parent is not NPbase");
6841
6842}
6843
6845{
6846 if ((this->getModel()).isModelLinearized()) {
6847 return ((myNPbase->STXS_WHqqHqq_pTj1_200(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
6848 } else {
6850 }
6851}
6852
6853
6855: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6856{
6857 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6858 throw std::runtime_error("STXSZHqqHqq_VBFtopo_j3v_2b called with a class whose parent is not NPbase");
6859
6860}
6861
6863{
6864 if ((this->getModel()).isModelLinearized()) {
6866 } else {
6868 }
6869}
6870
6871
6873: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6874{
6875 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6876 throw std::runtime_error("STXSZHqqHqq_VBFtopo_j3_2b called with a class whose parent is not NPbase");
6877
6878}
6879
6881{
6882 if ((this->getModel()).isModelLinearized()) {
6883 return ((myNPbase->STXS_ZHqqHqq_VBFtopo_j3(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
6884 } else {
6886 }
6887}
6888
6889
6891: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6892{
6893 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6894 throw std::runtime_error("STXSZHqqHqq_VH2j_2b called with a class whose parent is not NPbase");
6895
6896}
6897
6899{
6900 if ((this->getModel()).isModelLinearized()) {
6901 return ((myNPbase->STXS_ZHqqHqq_VH2j(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
6902 } else {
6904 }
6905}
6906
6907
6909: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6910{
6911 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6912 throw std::runtime_error("STXSZHqqHqq_Rest_2b called with a class whose parent is not NPbase");
6913
6914}
6915
6917{
6918 if ((this->getModel()).isModelLinearized()) {
6919 return ((myNPbase->STXS_ZHqqHqq_Rest(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
6920 } else {
6922 }
6923}
6924
6925
6927: ThObservable(SM_i), sqrt_s(sqrt_s_i)
6928{
6929 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6930 throw std::runtime_error("STXSZHqqHqq_pTj1_200_2b called with a class whose parent is not NPbase");
6931
6932}
6933
6935{
6936 if ((this->getModel()).isModelLinearized()) {
6937 return ((myNPbase->STXS_ZHqqHqq_pTj1_200(sqrt_s)) + (myNPbase->BrHbbRatio()) - 1.0);
6938 } else {
6940 }
6941}
6942
6943
6944
6945// -----------------------------------------------------------------------------
6946// Stage 1.2
6947// -----------------------------------------------------------------------------
6948
6949STXS12_ggH_pTH200_300_Nj01::STXS12_ggH_pTH200_300_Nj01(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
6950: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
6951{
6952 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6953 throw std::runtime_error("STXS12_ggH_pTH200_300_Nj01 called with a class whose parent is not NPbase");
6954
6955}
6956
6958{
6959 double BrHXXRatio = 1.0;
6960 if (fstate == 1){
6961 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
6962 } else if (fstate == 2){
6963 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
6964 } else if (fstate == 3){
6965 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
6966 } else if (fstate == 4){
6967 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
6968 } else {
6969 throw std::runtime_error("STXS12_ggH_pTH200_300_Nj01 called with invalid argument for final state in fstate_i");
6970 }
6971
6972 if ((this->getModel()).isModelLinearized()) {
6973 return ((myNPbase->STXS12_ggH_pTH200_300_Nj01(sqrt_s)) + (BrHXXRatio) - 1.0);
6974 } else {
6975 return (myNPbase->STXS12_ggH_pTH200_300_Nj01(sqrt_s))*(BrHXXRatio);
6976 }
6977}
6978
6979// -----------------------------------------------------------------------------
6980
6981STXS12_ggH_pTH300_450_Nj01::STXS12_ggH_pTH300_450_Nj01(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
6982: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
6983{
6984 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
6985 throw std::runtime_error("STXS12_ggH_pTH300_450_Nj01 called with a class whose parent is not NPbase");
6986
6987}
6988
6990{
6991 double BrHXXRatio = 1.0;
6992 if (fstate == 1){
6993 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
6994 } else if (fstate == 2){
6995 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
6996 } else if (fstate == 3){
6997 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
6998 } else if (fstate == 4){
6999 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7000 } else {
7001 throw std::runtime_error("STXS12_ggH_pTH300_450_Nj01 called with invalid argument for final state in fstate_i");
7002 }
7003
7004 if ((this->getModel()).isModelLinearized()) {
7005 return ((myNPbase->STXS12_ggH_pTH300_450_Nj01(sqrt_s)) + (BrHXXRatio) - 1.0);
7006 } else {
7007 return (myNPbase->STXS12_ggH_pTH300_450_Nj01(sqrt_s))*(BrHXXRatio);
7008 }
7009}
7010
7011// -----------------------------------------------------------------------------
7012
7013STXS12_ggH_pTH450_650_Nj01::STXS12_ggH_pTH450_650_Nj01(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7014: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7015{
7016 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7017 throw std::runtime_error("STXS12_ggH_pTH450_650_Nj01 called with a class whose parent is not NPbase");
7018
7019}
7020
7022{
7023 double BrHXXRatio = 1.0;
7024 if (fstate == 1){
7025 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7026 } else if (fstate == 2){
7027 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
7028 } else if (fstate == 3){
7029 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
7030 } else if (fstate == 4){
7031 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7032 } else {
7033 throw std::runtime_error("STXS12_ggH_pTH450_650_Nj01 called with invalid argument for final state in fstate_i");
7034 }
7035
7036 if ((this->getModel()).isModelLinearized()) {
7037 return ((myNPbase->STXS12_ggH_pTH450_650_Nj01(sqrt_s)) + (BrHXXRatio) - 1.0);
7038 } else {
7039 return (myNPbase->STXS12_ggH_pTH450_650_Nj01(sqrt_s))*(BrHXXRatio);
7040 }
7041}
7042
7043// -----------------------------------------------------------------------------
7044
7045STXS12_ggH_pTH650_Inf_Nj01::STXS12_ggH_pTH650_Inf_Nj01(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7046: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7047{
7048 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7049 throw std::runtime_error("STXS12_ggH_pTH650_Inf_Nj01 called with a class whose parent is not NPbase");
7050
7051}
7052
7054{
7055 double BrHXXRatio = 1.0;
7056 if (fstate == 1){
7057 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7058 } else if (fstate == 2){
7059 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
7060 } else if (fstate == 3){
7061 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
7062 } else if (fstate == 4){
7063 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7064 } else {
7065 throw std::runtime_error("STXS12_ggH_pTH650_Inf_Nj01 called with invalid argument for final state in fstate_i");
7066 }
7067
7068 if ((this->getModel()).isModelLinearized()) {
7069 return ((myNPbase->STXS12_ggH_pTH650_Inf_Nj01(sqrt_s)) + (BrHXXRatio) - 1.0);
7070 } else {
7071 return (myNPbase->STXS12_ggH_pTH650_Inf_Nj01(sqrt_s))*(BrHXXRatio);
7072 }
7073}
7074
7075
7076// -----------------------------------------------------------------------------
7077
7078STXS12_ggH_pTH10_Inf_Nj0::STXS12_ggH_pTH10_Inf_Nj0(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7079: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7080{
7081 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7082 throw std::runtime_error("STXS12_ggH_pTH10_Inf_Nj0 called with a class whose parent is not NPbase");
7083
7084}
7085
7087{
7088 //-- Production:
7089 double weight = 1.0; //If normalized to the SM
7090
7091 double muProd = myNPbase->STXS12_ggH_pTH10_Inf_Nj0(sqrt_s);
7092 double muProd1 = muProd -1.0;
7093 double muProd2 = 0.0;
7094 //-- Decay:
7095 double BrHXXRatio = 1.0;
7096 double dBrHXXRatio1 = 0.0;
7097 double dBrHXXRatio2 = 0.0;
7098
7099 if (fstate == 1){
7100 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7101 dBrHXXRatio1 = BrHXXRatio - 1.0;
7102 dBrHXXRatio2 = 0.0;
7103 } else if (fstate == 2){
7104 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
7105 dBrHXXRatio1 = BrHXXRatio - 1.0;
7106 dBrHXXRatio2 = 0.0;
7107 } else if (fstate == 3){
7108 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
7109 dBrHXXRatio1 = BrHXXRatio - 1.0;
7110 dBrHXXRatio2 = 0.0;
7111 } else if (fstate == 4){
7112 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7113 dBrHXXRatio1 = BrHXXRatio - 1.0;
7114 dBrHXXRatio2 = 0.0;
7115 } else {
7116 throw std::runtime_error("STXS12_ggH_pTH10_Inf_Nj0 called with invalid argument for final state in fstate_i");
7117 }
7118
7119 //-- Production x Decay:
7120 if ((this->getModel()).isModelLinearized()){
7121 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
7122 } else if((this->getModel()).isModelNPquadratic()){
7123 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
7124 } else {
7125 return weight*(muProd)*(BrHXXRatio);
7126 }
7127}
7128
7129
7130
7131
7132
7133// -----------------------------------------------------------------------------
7134
7135//VM:STXS2024;
7136STXS12_ggH_pTH0_10_Nj0::STXS12_ggH_pTH0_10_Nj0(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7137: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7138{
7139 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7140 throw std::runtime_error("STXS12_ggH_pTH0_10_Nj0 called with a class whose parent is not NPbase");
7141
7142}
7143
7145{
7146 //-- Production:
7147 double weight = 1.0; //If normalized to the SM
7148 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
7149 double muProd = myNPbase->STXS12_ggH_pTH0_10_Nj0(sqrt_s);
7150 double muProd1 = muProd -1.0;
7151 double muProd2 = 0.0;
7152
7153 //-- Decay:
7154 double BrHXXRatio = 1.0;
7155 double dBrHXXRatio1 = 0.0;
7156 double dBrHXXRatio2 = 0.0;
7157 if (fstate==0){
7158 // Use for Cross-section [pb] with no Higgs-boson decay
7159 weight = (6.6369); //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
7160 } else if (fstate == 1){
7161 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7162 dBrHXXRatio1 = BrHXXRatio - 1.0;
7163 dBrHXXRatio2 = 0.0;
7164 } else if (fstate == 2){
7165 BrHXXRatio = (myNPbase->BrHgagaRatio());
7166 dBrHXXRatio1 = BrHXXRatio - 1.0;
7167 dBrHXXRatio2 = 0.0;
7168 } else if (fstate == 3){
7169 BrHXXRatio = (myNPbase->BrHbbRatio());
7170 dBrHXXRatio1 = BrHXXRatio - 1.0;
7171 dBrHXXRatio2 = 0.0;
7172 } else if (fstate == 4){
7173 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7174 dBrHXXRatio1 = BrHXXRatio - 1.0;
7175 dBrHXXRatio2 = 0.0;
7176 } else if (fstate == 5){
7177 BrHXXRatio = (myNPbase->BrHtautauRatio());
7178 dBrHXXRatio1 = BrHXXRatio - 1.0;
7179 dBrHXXRatio2 = 0.0;
7180 } else if (fstate == 6){
7181 BrHXXRatio = (myNPbase->BrHWWRatio());
7182 dBrHXXRatio1 = BrHXXRatio - 1.0;
7183 dBrHXXRatio2 = 0.0;
7184 } else if (fstate == 7){
7185 BrHXXRatio = (myNPbase->BrHZZRatio());
7186 dBrHXXRatio1 = BrHXXRatio - 1.0;
7187 dBrHXXRatio2 = 0.0;
7188 } else {
7189 throw std::runtime_error("STXS12_ggH_pTH0_10_Nj0 called with invalid argument for final state in fstate_i");
7190 }
7191
7192 //-- Production x Decay:
7193 if ((this->getModel()).isModelLinearized()){
7194 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
7195 } else if((this->getModel()).isModelNPquadratic()){
7196 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
7197 } else {
7198 return weight*(muProd)*(BrHXXRatio);
7199 }
7200
7201}
7202
7203
7204
7205// -----------------------------------------------------------------------------
7206
7207//VM:STXS2024;
7208STXS12_ggH_pTH10_200_Nj0::STXS12_ggH_pTH10_200_Nj0(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7209: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7210{
7211 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7212 throw std::runtime_error("STXS12_ggH_pTH10_200_Nj0 called with a class whose parent is not NPbase");
7213
7214}
7215
7217{
7218 //-- Production:
7219 double weight = 1.0; //If normalized to the SM
7220 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
7221 double muProd = myNPbase->STXS12_ggH_pTH10_200_Nj0(sqrt_s);
7222 double muProd1 = muProd -1.0;
7223 double muProd2 = 0.0;
7224
7225 //-- Decay:
7226 double BrHXXRatio = 1.0;
7227 double dBrHXXRatio1 = 0.0;
7228 double dBrHXXRatio2 = 0.0;
7229 if (fstate==0){
7230 // Use for Cross-section [pb] with no Higgs-boson decay
7231 weight = (20.642); //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
7232 } else if (fstate == 1){
7233 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7234 dBrHXXRatio1 = BrHXXRatio - 1.0;
7235 dBrHXXRatio2 = 0.0;
7236 } else if (fstate == 2){
7237 BrHXXRatio = (myNPbase->BrHgagaRatio());
7238 dBrHXXRatio1 = BrHXXRatio - 1.0;
7239 dBrHXXRatio2 = 0.0;
7240 } else if (fstate == 3){
7241 BrHXXRatio = (myNPbase->BrHbbRatio());
7242 dBrHXXRatio1 = BrHXXRatio - 1.0;
7243 dBrHXXRatio2 = 0.0;
7244 } else if (fstate == 4){
7245 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7246 dBrHXXRatio1 = BrHXXRatio - 1.0;
7247 dBrHXXRatio2 = 0.0;
7248 } else if (fstate == 5){
7249 BrHXXRatio = (myNPbase->BrHtautauRatio());
7250 dBrHXXRatio1 = BrHXXRatio - 1.0;
7251 dBrHXXRatio2 = 0.0;
7252 } else if (fstate == 6){
7253 BrHXXRatio = (myNPbase->BrHWWRatio());
7254 dBrHXXRatio1 = BrHXXRatio - 1.0;
7255 dBrHXXRatio2 = 0.0;
7256 } else if (fstate == 7){
7257 BrHXXRatio = (myNPbase->BrHZZRatio());
7258 dBrHXXRatio1 = BrHXXRatio - 1.0;
7259 dBrHXXRatio2 = 0.0;
7260 } else {
7261 throw std::runtime_error("STXS12_ggH_pTH10_200_Nj0 called with invalid argument for final state in fstate_i");
7262 }
7263
7264 //-- Production x Decay:
7265 if ((this->getModel()).isModelLinearized()){
7266 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
7267 } else if((this->getModel()).isModelNPquadratic()){
7268 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
7269 } else {
7270 return weight*(muProd)*(BrHXXRatio);
7271 }
7272
7273}
7274
7275
7276
7277
7278// -----------------------------------------------------------------------------
7279
7280//VM:STXS2024;
7281STXS12_ggH_pTH0_200_Nj0::STXS12_ggH_pTH0_200_Nj0(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7282: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7283{
7284 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7285 throw std::runtime_error("STXS12_ggH_pTH0_200_Nj0 called with a class whose parent is not NPbase");
7286
7287}
7288
7290{
7291 //-- Production:
7292 double weight = 1.0; //If normalized to the SM
7293 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
7294 double muProd = ( 6.6369*(myNPbase->STXS12_ggH_pTH0_10_Nj0(sqrt_s)) +
7296 /(6.6369 + 20.642);
7297 double muProd1 = muProd -1.0;
7298 double muProd2 = 0.0;
7299
7300 //-- Decay:
7301 double BrHXXRatio = 1.0;
7302 double dBrHXXRatio1 = 0.0;
7303 double dBrHXXRatio2 = 0.0;
7304 if (fstate==0){
7305 // Use for Cross-section [pb] with no Higgs-boson decay
7306 weight = (6.6369 + 20.642); //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
7307 } else if (fstate == 1){
7308 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7309 dBrHXXRatio1 = BrHXXRatio - 1.0;
7310 dBrHXXRatio2 = 0.0;
7311 } else if (fstate == 2){
7312 BrHXXRatio = (myNPbase->BrHgagaRatio());
7313 dBrHXXRatio1 = BrHXXRatio - 1.0;
7314 dBrHXXRatio2 = 0.0;
7315 } else if (fstate == 3){
7316 BrHXXRatio = (myNPbase->BrHbbRatio());
7317 dBrHXXRatio1 = BrHXXRatio - 1.0;
7318 dBrHXXRatio2 = 0.0;
7319 } else if (fstate == 4){
7320 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7321 dBrHXXRatio1 = BrHXXRatio - 1.0;
7322 dBrHXXRatio2 = 0.0;
7323 } else if (fstate == 5){
7324 BrHXXRatio = (myNPbase->BrHtautauRatio());
7325 dBrHXXRatio1 = BrHXXRatio - 1.0;
7326 dBrHXXRatio2 = 0.0;
7327 } else if (fstate == 6){
7328 BrHXXRatio = (myNPbase->BrHWWRatio());
7329 dBrHXXRatio1 = BrHXXRatio - 1.0;
7330 dBrHXXRatio2 = 0.0;
7331 } else if (fstate == 7){
7332 BrHXXRatio = (myNPbase->BrHZZRatio());
7333 dBrHXXRatio1 = BrHXXRatio - 1.0;
7334 dBrHXXRatio2 = 0.0;
7335 } else {
7336 throw std::runtime_error("STXS12_ggH_pTH0_200_Nj0 called with invalid argument for final state in fstate_i");
7337 }
7338
7339 //-- Production x Decay:
7340 if ((this->getModel()).isModelLinearized()){
7341 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
7342 } else if((this->getModel()).isModelNPquadratic()){
7343 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
7344 } else {
7345 return weight*(muProd)*(BrHXXRatio);
7346 }
7347
7348}
7349
7350
7351
7352
7353// -----------------------------------------------------------------------------
7354
7355//VM:STXS2024;
7356STXS12_ggH_mjj0_350_pTH0_60_Nj1::STXS12_ggH_mjj0_350_pTH0_60_Nj1(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7357: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7358{
7359 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7360 throw std::runtime_error("STXS12_ggH_mjj0_350_pTH0_60_Nj1 called with a class whose parent is not NPbase");
7361
7362}
7363
7365{
7366 //-- Production:
7367 double weight = 1.0; //If normalized to the SM
7368 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
7369
7370 double muProd = ((myNPbase->STXS12_ggH_mjj0_350_pTH0_60_Nj1(sqrt_s)) );
7371 double muProd1 = muProd -1.0;
7372 double muProd2 = 0.0;
7373
7374 //-- Decay:
7375 double BrHXXRatio = 1.0;
7376 double dBrHXXRatio1 = 0.0;
7377 double dBrHXXRatio2 = 0.0;
7378 if (fstate==0){
7379 // Use for Cross-section [pb] with no Higgs-boson decay
7380 weight = (1.); //NOT in Ref: https://www.hepdata.net/record/ins2104706 Figure7. Missing SM prediction!!!
7381 } else if (fstate == 1){
7382 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7383 dBrHXXRatio1 = BrHXXRatio - 1.0;
7384 dBrHXXRatio2 = 0.0;
7385 } else if (fstate == 2){
7386 BrHXXRatio = (myNPbase->BrHgagaRatio());
7387 dBrHXXRatio1 = BrHXXRatio - 1.0;
7388 dBrHXXRatio2 = 0.0;
7389 } else if (fstate == 3){
7390 BrHXXRatio = (myNPbase->BrHbbRatio());
7391 dBrHXXRatio1 = BrHXXRatio - 1.0;
7392 dBrHXXRatio2 = 0.0;
7393 } else if (fstate == 4){
7394 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7395 dBrHXXRatio1 = BrHXXRatio - 1.0;
7396 dBrHXXRatio2 = 0.0;
7397 } else if (fstate == 5){
7398 BrHXXRatio = (myNPbase->BrHtautauRatio());
7399 dBrHXXRatio1 = BrHXXRatio - 1.0;
7400 dBrHXXRatio2 = 0.0;
7401 } else if (fstate == 6){
7402 BrHXXRatio = (myNPbase->BrHWWRatio());
7403 dBrHXXRatio1 = BrHXXRatio - 1.0;
7404 dBrHXXRatio2 = 0.0;
7405 } else if (fstate == 7){
7406 BrHXXRatio = (myNPbase->BrHZZRatio());
7407 dBrHXXRatio1 = BrHXXRatio - 1.0;
7408 dBrHXXRatio2 = 0.0;
7409 } else {
7410 throw std::runtime_error("STXS12_ggH_mjj0_350_pTH0_120_Nj1 called with invalid argument for final state in fstate_i");
7411 }
7412
7413 //-- Production x Decay:
7414 if ((this->getModel()).isModelLinearized()){
7415 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
7416 } else if((this->getModel()).isModelNPquadratic()){
7417 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
7418 } else {
7419 return weight*(muProd)*(BrHXXRatio);
7420 }
7421
7422}
7423
7424
7425
7426
7427
7428
7429
7430// -----------------------------------------------------------------------------
7431
7432//AG:STXS2024
7433STXS12_ggH_pTH0_60_Nj1::STXS12_ggH_pTH0_60_Nj1(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7434: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7435{
7436 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7437 throw std::runtime_error("STXS12_ggH_pTH0_60_Nj1 called with a class whose parent is not NPbase");
7438
7439}
7440
7442{
7443 //-- Production:
7444 double weight = 1.0; //If normalized to the SM
7445 double muProd = myNPbase->STXS12_ggH_pTH0_60_Nj1(sqrt_s);
7446 double muProd1 = muProd -1.0;
7447 double muProd2 = 0.0;
7448
7449 //-- Decay:
7450 double BrHXXRatio = 1.0;
7451 double dBrHXXRatio1 = 0.0;
7452 double dBrHXXRatio2 = 0.0;
7453 if (fstate==0){
7454 // Use for Cross-section [pb] with no Higgs-boson decay
7455 weight = 6.50045; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
7456 } else if (fstate == 1){
7457 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7458 dBrHXXRatio1 = BrHXXRatio - 1.0;
7459 dBrHXXRatio2 = 0.0;
7460 } else if (fstate == 2){
7461 BrHXXRatio = (myNPbase->BrHgagaRatio());
7462 dBrHXXRatio1 = BrHXXRatio - 1.0;
7463 dBrHXXRatio2 = 0.0;
7464 } else if (fstate == 3){
7465 BrHXXRatio = (myNPbase->BrHbbRatio());
7466 dBrHXXRatio1 = BrHXXRatio - 1.0;
7467 dBrHXXRatio2 = 0.0;
7468 } else if (fstate == 4){
7469 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7470 dBrHXXRatio1 = BrHXXRatio - 1.0;
7471 dBrHXXRatio2 = 0.0;
7472 } else if (fstate == 5){
7473 BrHXXRatio = (myNPbase->BrHtautauRatio());
7474 dBrHXXRatio1 = BrHXXRatio - 1.0;
7475 dBrHXXRatio2 = 0.0;
7476 } else if (fstate == 6){
7477 BrHXXRatio = (myNPbase->BrHWWRatio());
7478 dBrHXXRatio1 = BrHXXRatio - 1.0;
7479 dBrHXXRatio2 = 0.0;
7480 } else if (fstate == 7){
7481 BrHXXRatio = (myNPbase->BrHZZRatio());
7482 dBrHXXRatio1 = BrHXXRatio - 1.0;
7483 dBrHXXRatio2 = 0.0;
7484 } else {
7485 throw std::runtime_error("STXS12_ggH_pTH0_60_Nj1 called with invalid argument for final state in fstate_i");
7486 }
7487
7488 //-- Production x Decay:
7489 if ((this->getModel()).isModelLinearized()){
7490 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
7491 } else if((this->getModel()).isModelNPquadratic()){
7492 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
7493 } else {
7494 return weight*(muProd)*(BrHXXRatio);
7495 }
7496
7497}
7498
7499// -----------------------------------------------------------------------------
7500
7501//AG:STXS2024
7502STXS12_ggH_pTH60_120_Nj1::STXS12_ggH_pTH60_120_Nj1(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7503: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7504{
7505 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7506 throw std::runtime_error("STXS12_ggH_pTH60_120_Nj1 called with a class whose parent is not NPbase");
7507
7508}
7509
7511{
7512 //-- Production:
7513 double weight = 1.0; //If normalized to the SM
7514 double muProd = myNPbase->STXS12_ggH_pTH60_120_Nj1(sqrt_s);
7515 double muProd1 = muProd -1.0;
7516 double muProd2 = 0.0;
7517
7518 //-- Decay:
7519 double BrHXXRatio = 1.0;
7520 double dBrHXXRatio1 = 0.0;
7521 double dBrHXXRatio2 = 0.0;
7522 if (fstate==0){
7523 // Use for Cross-section [pb] with no Higgs-boson decay
7524 weight = 4.50294; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
7525 } else if (fstate == 1){
7526 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7527 dBrHXXRatio1 = BrHXXRatio - 1.0;
7528 dBrHXXRatio2 = 0.0;
7529 } else if (fstate == 2){
7530 BrHXXRatio = (myNPbase->BrHgagaRatio());
7531 dBrHXXRatio1 = BrHXXRatio - 1.0;
7532 dBrHXXRatio2 = 0.0;
7533 } else if (fstate == 3){
7534 BrHXXRatio = (myNPbase->BrHbbRatio());
7535 dBrHXXRatio1 = BrHXXRatio - 1.0;
7536 dBrHXXRatio2 = 0.0;
7537 } else if (fstate == 4){
7538 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7539 dBrHXXRatio1 = BrHXXRatio - 1.0;
7540 dBrHXXRatio2 = 0.0;
7541 } else if (fstate == 5){
7542 BrHXXRatio = (myNPbase->BrHtautauRatio());
7543 dBrHXXRatio1 = BrHXXRatio - 1.0;
7544 dBrHXXRatio2 = 0.0;
7545 } else if (fstate == 6){
7546 BrHXXRatio = (myNPbase->BrHWWRatio());
7547 dBrHXXRatio1 = BrHXXRatio - 1.0;
7548 dBrHXXRatio2 = 0.0;
7549 } else if (fstate == 7){
7550 BrHXXRatio = (myNPbase->BrHZZRatio());
7551 dBrHXXRatio1 = BrHXXRatio - 1.0;
7552 dBrHXXRatio2 = 0.0;
7553 } else {
7554 throw std::runtime_error("STXS12_ggH_pTH60_120_Nj1 called with invalid argument for final state in fstate_i");
7555 }
7556
7557 //-- Production x Decay:
7558 if ((this->getModel()).isModelLinearized()){
7559 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
7560 } else if((this->getModel()).isModelNPquadratic()){
7561 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
7562 } else {
7563 return weight*(muProd)*(BrHXXRatio);
7564 }
7565
7566}
7567
7568// -----------------------------------------------------------------------------
7569
7570//AG:STXS2024
7571STXS12_ggH_pTH120_200_Nj1::STXS12_ggH_pTH120_200_Nj1(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7572: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7573{
7574 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7575 throw std::runtime_error("STXS12_ggH_pTH120_200_Nj1 called with a class whose parent is not NPbase");
7576
7577}
7578
7580{
7581 //-- Production:
7582 double weight = 1.0; //If normalized to the SM
7583 double muProd = myNPbase->STXS12_ggH_pTH120_200_Nj1(sqrt_s);
7584 double muProd1 = muProd -1.0;
7585 double muProd2 = 0.0;
7586
7587 //-- Decay:
7588 double BrHXXRatio = 1.0;
7589 double dBrHXXRatio1 = 0.0;
7590 double dBrHXXRatio2 = 0.0;
7591 if (fstate==0){
7592 // Use for Cross-section [pb] with no Higgs-boson decay
7593 weight = 0.74712; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
7594 } else if (fstate == 1){
7595 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7596 dBrHXXRatio1 = BrHXXRatio - 1.0;
7597 dBrHXXRatio2 = 0.0;
7598 } else if (fstate == 2){
7599 BrHXXRatio = (myNPbase->BrHgagaRatio());
7600 dBrHXXRatio1 = BrHXXRatio - 1.0;
7601 dBrHXXRatio2 = 0.0;
7602 } else if (fstate == 3){
7603 BrHXXRatio = (myNPbase->BrHbbRatio());
7604 dBrHXXRatio1 = BrHXXRatio - 1.0;
7605 dBrHXXRatio2 = 0.0;
7606 } else if (fstate == 4){
7607 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7608 dBrHXXRatio1 = BrHXXRatio - 1.0;
7609 dBrHXXRatio2 = 0.0;
7610 } else if (fstate == 5){
7611 BrHXXRatio = (myNPbase->BrHtautauRatio());
7612 dBrHXXRatio1 = BrHXXRatio - 1.0;
7613 dBrHXXRatio2 = 0.0;
7614 } else if (fstate == 6){
7615 BrHXXRatio = (myNPbase->BrHWWRatio());
7616 dBrHXXRatio1 = BrHXXRatio - 1.0;
7617 dBrHXXRatio2 = 0.0;
7618 } else if (fstate == 7){
7619 BrHXXRatio = (myNPbase->BrHZZRatio());
7620 dBrHXXRatio1 = BrHXXRatio - 1.0;
7621 dBrHXXRatio2 = 0.0;
7622 } else {
7623 throw std::runtime_error("STXS12_ggH_pTH120_200_Nj1 called with invalid argument for final state in fstate_i");
7624 }
7625
7626 //-- Production x Decay:
7627 if ((this->getModel()).isModelLinearized()){
7628 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
7629 } else if((this->getModel()).isModelNPquadratic()){
7630 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
7631 } else {
7632 return weight*(muProd)*(BrHXXRatio);
7633 }
7634
7635}
7636
7637// -----------------------------------------------------------------------------
7638
7639STXS12_ggH_mjj0_350_pTH0_60_Nj2::STXS12_ggH_mjj0_350_pTH0_60_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7640: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7641{
7642 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7643 throw std::runtime_error("STXS12_ggH_mjj0_350_pTH0_60_Nj2 called with a class whose parent is not NPbase");
7644
7645}
7646
7648{
7649 double BrHXXRatio = 1.0;
7650 if (fstate == 1){
7651 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7652 } else if (fstate == 2){
7653 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
7654 } else if (fstate == 3){
7655 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
7656 } else if (fstate == 4){
7657 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7658 } else {
7659 throw std::runtime_error("STXS12_ggH_mjj0_350_pTH0_60_Nj2 called with invalid argument for final state in fstate_i");
7660 }
7661
7662 if ((this->getModel()).isModelLinearized()) {
7663 return ((myNPbase->STXS12_ggH_mjj0_350_pTH0_60_Nj2(sqrt_s)) + (BrHXXRatio) - 1.0);
7664 } else {
7665 return (myNPbase->STXS12_ggH_mjj0_350_pTH0_60_Nj2(sqrt_s))*(BrHXXRatio);
7666 }
7667}
7668
7669// -----------------------------------------------------------------------------
7670
7671STXS12_ggH_mjj0_350_pTH60_120_Nj2::STXS12_ggH_mjj0_350_pTH60_120_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7672: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7673{
7674 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7675 throw std::runtime_error("STXS12_ggH_mjj0_350_pTH60_120_Nj2 called with a class whose parent is not NPbase");
7676
7677}
7678
7680{
7681 double BrHXXRatio = 1.0;
7682 if (fstate == 1){
7683 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7684 } else if (fstate == 2){
7685 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
7686 } else if (fstate == 3){
7687 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
7688 } else if (fstate == 4){
7689 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7690 } else {
7691 throw std::runtime_error("STXS12_ggH_mjj0_350_pTH60_120_Nj2 called with invalid argument for final state in fstate_i");
7692 }
7693
7694 if ((this->getModel()).isModelLinearized()) {
7695 return ((myNPbase->STXS12_ggH_mjj0_350_pTH60_120_Nj2(sqrt_s)) + (BrHXXRatio) - 1.0);
7696 } else {
7697 return (myNPbase->STXS12_ggH_mjj0_350_pTH60_120_Nj2(sqrt_s))*(BrHXXRatio);
7698 }
7699}
7700
7701
7702
7703
7704
7705// -----------------------------------------------------------------------------
7706
7707//VM:STXS2024;
7708STXS12_ggH_mjj0_350_pTH0_120_Nj2::STXS12_ggH_mjj0_350_pTH0_120_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7709: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7710{
7711 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7712 throw std::runtime_error("STXS12_ggH_mjj0_350_pTH0_120_Nj2 called with a class whose parent is not NPbase");
7713
7714}
7715
7717{
7718 //-- Production:
7719 double weight = 1.0; //If normalized to the SM
7720 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
7721 //We should weight each xsection with the SM prediction. We need to check
7722 //this values, nevertheless, the difference between the two parametrisations
7723 //is extremely small (way beyond our current precision)
7724 double muProd = ((myNPbase->STXS12_ggH_mjj0_350_pTH0_60_Nj2(sqrt_s)) +
7726 /(2.);
7727 double muProd1 = muProd -1.0;
7728 double muProd2 = 0.0;
7729
7730 //-- Decay:
7731 double BrHXXRatio = 1.0;
7732 double dBrHXXRatio1 = 0.0;
7733 double dBrHXXRatio2 = 0.0;
7734 if (fstate==0){
7735 // Use for Cross-section [pb] with no Higgs-boson decay
7736 weight = (2.9636); //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
7737 } else if (fstate == 1){
7738 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7739 dBrHXXRatio1 = BrHXXRatio - 1.0;
7740 dBrHXXRatio2 = 0.0;
7741 } else if (fstate == 2){
7742 BrHXXRatio = (myNPbase->BrHgagaRatio());
7743 dBrHXXRatio1 = BrHXXRatio - 1.0;
7744 dBrHXXRatio2 = 0.0;
7745 } else if (fstate == 3){
7746 BrHXXRatio = (myNPbase->BrHbbRatio());
7747 dBrHXXRatio1 = BrHXXRatio - 1.0;
7748 dBrHXXRatio2 = 0.0;
7749 } else if (fstate == 4){
7750 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7751 dBrHXXRatio1 = BrHXXRatio - 1.0;
7752 dBrHXXRatio2 = 0.0;
7753 } else if (fstate == 5){
7754 BrHXXRatio = (myNPbase->BrHtautauRatio());
7755 dBrHXXRatio1 = BrHXXRatio - 1.0;
7756 dBrHXXRatio2 = 0.0;
7757 } else if (fstate == 6){
7758 BrHXXRatio = (myNPbase->BrHWWRatio());
7759 dBrHXXRatio1 = BrHXXRatio - 1.0;
7760 dBrHXXRatio2 = 0.0;
7761 } else if (fstate == 7){
7762 BrHXXRatio = (myNPbase->BrHZZRatio());
7763 dBrHXXRatio1 = BrHXXRatio - 1.0;
7764 dBrHXXRatio2 = 0.0;
7765 } else {
7766 throw std::runtime_error("STXS12_ggH_mjj0_350_pTH0_120_Nj2 called with invalid argument for final state in fstate_i");
7767 }
7768
7769 //-- Production x Decay:
7770 if ((this->getModel()).isModelLinearized()){
7771 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
7772 } else if((this->getModel()).isModelNPquadratic()){
7773 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
7774 } else {
7775 return weight*(muProd)*(BrHXXRatio);
7776 }
7777
7778}
7779
7780
7781
7782
7783// -----------------------------------------------------------------------------
7784
7785//AG:STXS2024
7786STXS12_ggH_mjj0_350_pTH120_200_Nj2::STXS12_ggH_mjj0_350_pTH120_200_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7787: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7788{
7789 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7790 throw std::runtime_error("STXS12_ggH_mjj0_350_pTH120_200_Nj2 called with a class whose parent is not NPbase");
7791
7792}
7793
7795{
7796 //-- Production:
7797 double weight = 1.0; //If normalized to the SM
7799 double muProd1 = muProd -1.0;
7800 double muProd2 = 0.0;
7801
7802 //-- Decay:
7803 double BrHXXRatio = 1.0;
7804 double dBrHXXRatio1 = 0.0;
7805 double dBrHXXRatio2 = 0.0;
7806 if (fstate==0){
7807 // Use for Cross-section [pb] with no Higgs-boson decay
7808 weight = 0.94325; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
7809 } else if (fstate == 1){
7810 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7811 dBrHXXRatio1 = BrHXXRatio - 1.0;
7812 dBrHXXRatio2 = 0.0;
7813 } else if (fstate == 2){
7814 BrHXXRatio = (myNPbase->BrHgagaRatio());
7815 dBrHXXRatio1 = BrHXXRatio - 1.0;
7816 dBrHXXRatio2 = 0.0;
7817 } else if (fstate == 3){
7818 BrHXXRatio = (myNPbase->BrHbbRatio());
7819 dBrHXXRatio1 = BrHXXRatio - 1.0;
7820 dBrHXXRatio2 = 0.0;
7821 } else if (fstate == 4){
7822 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7823 dBrHXXRatio1 = BrHXXRatio - 1.0;
7824 dBrHXXRatio2 = 0.0;
7825 } else if (fstate == 5){
7826 BrHXXRatio = (myNPbase->BrHtautauRatio());
7827 dBrHXXRatio1 = BrHXXRatio - 1.0;
7828 dBrHXXRatio2 = 0.0;
7829 }else {
7830 throw std::runtime_error("STXS12_ggH_mjj0_350_pTH120_200_Nj2 called with invalid argument for final state in fstate_i");
7831 }
7832
7833 //-- Production x Decay:
7834 if ((this->getModel()).isModelLinearized()){
7835 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
7836 } else if((this->getModel()).isModelNPquadratic()){
7837 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
7838 } else {
7839 return weight*(muProd)*(BrHXXRatio);
7840 }
7841
7842}
7843
7844
7845
7846
7847//VM:STXS2024;
7848STXS12_ggH_mjj350_Inf_pTH0_200_Nj2::STXS12_ggH_mjj350_Inf_pTH0_200_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
7849: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7850{
7851 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7852 throw std::runtime_error("STXS12_ggH_mjj350_Inf_pTH0_200_Nj2 called with a class whose parent is not NPbase");
7853
7854}
7855
7857{
7858 //-- Production:
7859 double weight = 1.0; //If normalized to the SM
7860 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
7861 //We should weight each xsection with the SM prediction. We need to check
7862 //this values, nevertheless, the difference between the two parametrisations
7863 //is extremely small (way beyond our current precision)
7866 /(2.);
7867 double muProd1 = muProd -1.0;
7868 double muProd2 = 0.0;
7869
7870 //-- Decay:
7871 double BrHXXRatio = 1.0;
7872 double dBrHXXRatio1 = 0.0;
7873 double dBrHXXRatio2 = 0.0;
7874 if (fstate==0){
7875 // Use for Cross-section [pb] with no Higgs-boson decay
7876 weight = (0.92136); //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
7877 } else if (fstate == 1){
7878 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7879 dBrHXXRatio1 = BrHXXRatio - 1.0;
7880 dBrHXXRatio2 = 0.0;
7881 } else if (fstate == 2){
7882 BrHXXRatio = (myNPbase->BrHgagaRatio());
7883 dBrHXXRatio1 = BrHXXRatio - 1.0;
7884 dBrHXXRatio2 = 0.0;
7885 } else if (fstate == 3){
7886 BrHXXRatio = (myNPbase->BrHbbRatio());
7887 dBrHXXRatio1 = BrHXXRatio - 1.0;
7888 dBrHXXRatio2 = 0.0;
7889 } else if (fstate == 4){
7890 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7891 dBrHXXRatio1 = BrHXXRatio - 1.0;
7892 dBrHXXRatio2 = 0.0;
7893 } else if (fstate == 5){
7894 BrHXXRatio = (myNPbase->BrHtautauRatio());
7895 dBrHXXRatio1 = BrHXXRatio - 1.0;
7896 dBrHXXRatio2 = 0.0;
7897 } else if (fstate == 6){
7898 BrHXXRatio = (myNPbase->BrHWWRatio());
7899 dBrHXXRatio1 = BrHXXRatio - 1.0;
7900 dBrHXXRatio2 = 0.0;
7901 } else if (fstate == 7){
7902 BrHXXRatio = (myNPbase->BrHZZRatio());
7903 dBrHXXRatio1 = BrHXXRatio - 1.0;
7904 dBrHXXRatio2 = 0.0;
7905 } else {
7906 throw std::runtime_error("STXS12_ggH_mjj350_Inf_pTH0_200_Nj2 called with invalid argument for final state in fstate_i");
7907 }
7908
7909 //-- Production x Decay:
7910 if ((this->getModel()).isModelLinearized()){
7911 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
7912 } else if((this->getModel()).isModelNPquadratic()){
7913 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
7914 } else {
7915 return weight*(muProd)*(BrHXXRatio);
7916 }
7917
7918}
7919
7920
7921// -----------------------------------------------------------------------------
7922
7924: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7925{
7926 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7927 throw std::runtime_error("STXS12_ggH_mjj350_700_pTH0_200_ptHjj0_25_Nj2 called with a class whose parent is not NPbase");
7928
7929}
7930
7932{
7933 double BrHXXRatio = 1.0;
7934 if (fstate == 1){
7935 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7936 } else if (fstate == 2){
7937 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
7938 } else if (fstate == 3){
7939 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
7940 } else if (fstate == 4){
7941 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7942 } else {
7943 throw std::runtime_error("STXS12_ggH_mjj350_700_pTH0_200_ptHjj0_25_Nj2 called with invalid argument for final state in fstate_i");
7944 }
7945
7946 if ((this->getModel()).isModelLinearized()) {
7947 return ((myNPbase->STXS12_ggH_mjj350_700_pTH0_200_ptHjj0_25_Nj2(sqrt_s)) + (BrHXXRatio) - 1.0);
7948 } else {
7950 }
7951}
7952
7953// -----------------------------------------------------------------------------
7954
7956: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7957{
7958
7959 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7960 throw std::runtime_error("STXS12_ggH_mjj350_700_pTH0_200_ptHjj25_Inf_Nj2 called with a class whose parent is not NPbase");
7961
7962}
7963
7965{
7966 double BrHXXRatio = 1.0;
7967 if (fstate == 1){
7968 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
7969 } else if (fstate == 2){
7970 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
7971 } else if (fstate == 3){
7972 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
7973 } else if (fstate == 4){
7974 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
7975 } else {
7976 throw std::runtime_error("STXS12_ggH_mjj350_700_pTH0_200_ptHjj25_Inf_Nj2 called with invalid argument for final state in fstate_i");
7977 }
7978
7979 if ((this->getModel()).isModelLinearized()) {
7980 return ((myNPbase->STXS12_ggH_mjj350_700_pTH0_200_ptHjj25_Inf_Nj2(sqrt_s)) + (BrHXXRatio) - 1.0);
7981 } else {
7983 }
7984}
7985
7986// -----------------------------------------------------------------------------
7987
7989: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7990{
7991 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
7992 throw std::runtime_error("STXS12_ggH_mjj700_Inf_pTH0_200_ptHjj0_25_Nj2 called with a class whose parent is not NPbase");
7993
7994}
7995
7997{
7998 double BrHXXRatio = 1.0;
7999 if (fstate == 1){
8000 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8001 } else if (fstate == 2){
8002 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
8003 } else if (fstate == 3){
8004 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
8005 } else if (fstate == 4){
8006 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8007 } else {
8008 throw std::runtime_error("STXS12_ggH_mjj700_Inf_pTH0_200_ptHjj0_25_Nj2 called with invalid argument for final state in fstate_i");
8009 }
8010
8011 if ((this->getModel()).isModelLinearized()) {
8012 return ((myNPbase->STXS12_ggH_mjj700_Inf_pTH0_200_ptHjj0_25_Nj2(sqrt_s)) + (BrHXXRatio) - 1.0);
8013 } else {
8015 }
8016}
8017
8018// -----------------------------------------------------------------------------
8019
8021: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8022{
8023 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8024 throw std::runtime_error("STXS12_ggH_mjj700_Inf_pTH0_200_ptHjj25_Inf_Nj2 called with a class whose parent is not NPbase");
8025
8026}
8027
8029{
8030 double BrHXXRatio = 1.0;
8031 if (fstate == 1){
8032 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8033 } else if (fstate == 2){
8034 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
8035 } else if (fstate == 3){
8036 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
8037 } else if (fstate == 4){
8038 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8039 } else {
8040 throw std::runtime_error("STXS12_ggH_mjj700_Inf_pTH0_200_ptHjj25_Inf_Nj2 called with invalid argument for final state in fstate_i");
8041 }
8042
8043 if ((this->getModel()).isModelLinearized()) {
8044 return ((myNPbase->STXS12_ggH_mjj700_Inf_pTH0_200_ptHjj25_Inf_Nj2(sqrt_s)) + (BrHXXRatio) - 1.0);
8045 } else {
8047 }
8048}
8049
8050
8051
8052
8053
8054// -----------------------------------------------------------------------------
8055
8056//VM:STXS2024;
8057STXS12_ggH_pTH0_200_Nj2::STXS12_ggH_pTH0_200_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8058: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8059{
8060 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8061 throw std::runtime_error("STXS12_ggH_pTH0_200_Nj2 called with a class whose parent is not NPbase");
8062
8063}
8064
8066{
8067
8068
8069
8070 //-- Production:
8071 double weight = 1.0; //If normalized to the SM
8072 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
8073 //VM: In the reference above we have the SM predictions for less bins. Angelica should have
8074 //the ones for Madgraph and we could use those. In any case the parametrisation is very stable
8075 //we give the same weight to the bins for which we don't have the SM prediction (for the moment)!
8076 //The possible error that we could be introducing here is way below our precision!
8077 double muProd = (
8081 )/(2.9636+0.94321+0.87751);
8082 double muProd1 = muProd -1.0;
8083 double muProd2 = 0.0;
8084
8085 //-- Decay:
8086 double BrHXXRatio = 1.0;
8087 double dBrHXXRatio1 = 0.0;
8088 double dBrHXXRatio2 = 0.0;
8089 if (fstate==0){
8090 // Use for Cross-section [pb] with no Higgs-boson decay
8091 weight = (2.9636+0.94321+0.87751); //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
8092 } else if (fstate == 1){
8093 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8094 dBrHXXRatio1 = BrHXXRatio - 1.0;
8095 dBrHXXRatio2 = 0.0;
8096 } else if (fstate == 2){
8097 BrHXXRatio = (myNPbase->BrHgagaRatio());
8098 dBrHXXRatio1 = BrHXXRatio - 1.0;
8099 dBrHXXRatio2 = 0.0;
8100 } else if (fstate == 3){
8101 BrHXXRatio = (myNPbase->BrHbbRatio());
8102 dBrHXXRatio1 = BrHXXRatio - 1.0;
8103 dBrHXXRatio2 = 0.0;
8104 } else if (fstate == 4){
8105 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8106 dBrHXXRatio1 = BrHXXRatio - 1.0;
8107 dBrHXXRatio2 = 0.0;
8108 } else if (fstate == 5){
8109 BrHXXRatio = (myNPbase->BrHtautauRatio());
8110 dBrHXXRatio1 = BrHXXRatio - 1.0;
8111 dBrHXXRatio2 = 0.0;
8112 } else if (fstate == 6){
8113 BrHXXRatio = (myNPbase->BrHWWRatio());
8114 dBrHXXRatio1 = BrHXXRatio - 1.0;
8115 dBrHXXRatio2 = 0.0;
8116 } else if (fstate == 7){
8117 BrHXXRatio = (myNPbase->BrHZZRatio());
8118 dBrHXXRatio1 = BrHXXRatio - 1.0;
8119 dBrHXXRatio2 = 0.0;
8120 } else {
8121 throw std::runtime_error("STXS12_ggH_pTH0_200_Nj2 called with invalid argument for final state in fstate_i");
8122 }
8123
8124 //-- Production x Decay:
8125 if ((this->getModel()).isModelLinearized()){
8126 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
8127 } else if((this->getModel()).isModelNPquadratic()){
8128 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
8129 } else {
8130 return weight*(muProd)*(BrHXXRatio);
8131 }
8132
8133}
8134
8135
8136
8137
8138
8139
8140
8141// -----------------------------------------------------------------------------
8142
8143
8144//VM:STXS2024;
8145STXS12_ggH_pTH200_Inf::STXS12_ggH_pTH200_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8146: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8147{
8148 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8149 throw std::runtime_error("STXS12_ggH_pTH200_Inf called with a class whose parent is not NPbase");
8150
8151}
8152
8154{
8155 //-- Production:
8156 double weight = 1.0; //If normalized to the SM
8157 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
8158 double muProd = ( 0.45825*(myNPbase->STXS12_ggH_pTH200_300(sqrt_s)) +
8161 /(0.45825 + 0.10632 + 0.017974);
8162 double muProd1 = muProd -1.0;
8163 double muProd2 = 0.0;
8164
8165 //-- Decay:
8166 double BrHXXRatio = 1.0;
8167 double dBrHXXRatio1 = 0.0;
8168 double dBrHXXRatio2 = 0.0;
8169 if (fstate==0){
8170 // Use for Cross-section [pb] with no Higgs-boson decay
8171 weight = (0.45825 + 0.10632 + 0.017974); //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
8172 } else if (fstate == 1){
8173 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8174 dBrHXXRatio1 = BrHXXRatio - 1.0;
8175 dBrHXXRatio2 = 0.0;
8176 } else if (fstate == 2){
8177 BrHXXRatio = (myNPbase->BrHgagaRatio());
8178 dBrHXXRatio1 = BrHXXRatio - 1.0;
8179 dBrHXXRatio2 = 0.0;
8180 } else if (fstate == 3){
8181 BrHXXRatio = (myNPbase->BrHbbRatio());
8182 dBrHXXRatio1 = BrHXXRatio - 1.0;
8183 dBrHXXRatio2 = 0.0;
8184 } else if (fstate == 4){
8185 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8186 dBrHXXRatio1 = BrHXXRatio - 1.0;
8187 dBrHXXRatio2 = 0.0;
8188 } else if (fstate == 5){
8189 BrHXXRatio = (myNPbase->BrHtautauRatio());
8190 dBrHXXRatio1 = BrHXXRatio - 1.0;
8191 dBrHXXRatio2 = 0.0;
8192 } else if (fstate == 6){
8193 BrHXXRatio = (myNPbase->BrHWWRatio());
8194 dBrHXXRatio1 = BrHXXRatio - 1.0;
8195 dBrHXXRatio2 = 0.0;
8196 } else if (fstate == 7){
8197 BrHXXRatio = (myNPbase->BrHZZRatio());
8198 dBrHXXRatio1 = BrHXXRatio - 1.0;
8199 dBrHXXRatio2 = 0.0;
8200 } else {
8201 throw std::runtime_error("STXS12_ggH_pTH200_Inf called with invalid argument for final state in fstate_i");
8202 }
8203
8204 //-- Production x Decay:
8205 if ((this->getModel()).isModelLinearized()){
8206 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
8207 } else if((this->getModel()).isModelNPquadratic()){
8208 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
8209 } else {
8210 return weight*(muProd)*(BrHXXRatio);
8211 }
8212
8213}
8214
8215
8216
8217
8218// -----------------------------------------------------------------------------
8219
8220
8221//VM:STXS2024;
8222STXS12_ggH_pTH300_Inf::STXS12_ggH_pTH300_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8223: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8224{
8225 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8226 throw std::runtime_error("STXS12_ggH_pTH300_Inf called with a class whose parent is not NPbase");
8227
8228}
8229
8231{
8232 //-- Production:
8233 double weight = 1.0; //If normalized to the SM
8234 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
8235 double muProd = (0.10632*(myNPbase->STXS12_ggH_pTH300_450(sqrt_s)) +
8237 /(0.10632 + 0.017974);
8238 double muProd1 = muProd -1.0;
8239 double muProd2 = 0.0;
8240
8241 //-- Decay:
8242 double BrHXXRatio = 1.0;
8243 double dBrHXXRatio1 = 0.0;
8244 double dBrHXXRatio2 = 0.0;
8245 if (fstate==0){
8246 // Use for Cross-section [pb] with no Higgs-boson decay
8247 weight = (0.10632 + 0.017974); //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
8248 } else if (fstate == 1){
8249 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8250 dBrHXXRatio1 = BrHXXRatio - 1.0;
8251 dBrHXXRatio2 = 0.0;
8252 } else if (fstate == 2){
8253 BrHXXRatio = (myNPbase->BrHgagaRatio());
8254 dBrHXXRatio1 = BrHXXRatio - 1.0;
8255 dBrHXXRatio2 = 0.0;
8256 } else if (fstate == 3){
8257 BrHXXRatio = (myNPbase->BrHbbRatio());
8258 dBrHXXRatio1 = BrHXXRatio - 1.0;
8259 dBrHXXRatio2 = 0.0;
8260 } else if (fstate == 4){
8261 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8262 dBrHXXRatio1 = BrHXXRatio - 1.0;
8263 dBrHXXRatio2 = 0.0;
8264 } else if (fstate == 5){
8265 BrHXXRatio = (myNPbase->BrHtautauRatio());
8266 dBrHXXRatio1 = BrHXXRatio - 1.0;
8267 dBrHXXRatio2 = 0.0;
8268 } else if (fstate == 6){
8269 BrHXXRatio = (myNPbase->BrHWWRatio());
8270 dBrHXXRatio1 = BrHXXRatio - 1.0;
8271 dBrHXXRatio2 = 0.0;
8272 } else if (fstate == 7){
8273 BrHXXRatio = (myNPbase->BrHZZRatio());
8274 dBrHXXRatio1 = BrHXXRatio - 1.0;
8275 dBrHXXRatio2 = 0.0;
8276 } else {
8277 throw std::runtime_error("STXS12_ggH_pTH200_Inf called with invalid argument for final state in fstate_i");
8278 }
8279
8280 //-- Production x Decay:
8281 if ((this->getModel()).isModelLinearized()){
8282 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
8283 } else if((this->getModel()).isModelNPquadratic()){
8284 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
8285 } else {
8286 return weight*(muProd)*(BrHXXRatio);
8287 }
8288
8289}
8290
8291
8292// -----------------------------------------------------------------------------
8293
8294
8295//VM:STXS2024;
8296STXS12_ggH_pTH200_300::STXS12_ggH_pTH200_300(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8297: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8298{
8299 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8300 throw std::runtime_error("STXS12_ggH_pTH200_300 called with a class whose parent is not NPbase");
8301
8302}
8303
8305{
8306 //-- Production:
8307 double weight = 1.0; //If normalized to the SM
8308 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
8309 double muProd = myNPbase->STXS12_ggH_pTH200_300(sqrt_s);
8310 double muProd1 = muProd -1.0;
8311 double muProd2 = 0.0;
8312
8313 //-- Decay:
8314 double BrHXXRatio = 1.0;
8315 double dBrHXXRatio1 = 0.0;
8316 double dBrHXXRatio2 = 0.0;
8317 if (fstate==0){
8318 // Use for Cross-section [pb] with no Higgs-boson decay
8319 weight = (0.45825 ); //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
8320 } else if (fstate == 1){
8321 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8322 dBrHXXRatio1 = BrHXXRatio - 1.0;
8323 dBrHXXRatio2 = 0.0;
8324 } else if (fstate == 2){
8325 BrHXXRatio = (myNPbase->BrHgagaRatio());
8326 dBrHXXRatio1 = BrHXXRatio - 1.0;
8327 dBrHXXRatio2 = 0.0;
8328 } else if (fstate == 3){
8329 BrHXXRatio = (myNPbase->BrHbbRatio());
8330 dBrHXXRatio1 = BrHXXRatio - 1.0;
8331 dBrHXXRatio2 = 0.0;
8332 } else if (fstate == 4){
8333 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8334 dBrHXXRatio1 = BrHXXRatio - 1.0;
8335 dBrHXXRatio2 = 0.0;
8336 } else if (fstate == 5){
8337 BrHXXRatio = (myNPbase->BrHtautauRatio());
8338 dBrHXXRatio1 = BrHXXRatio - 1.0;
8339 dBrHXXRatio2 = 0.0;
8340 } else if (fstate == 6){
8341 BrHXXRatio = (myNPbase->BrHWWRatio());
8342 dBrHXXRatio1 = BrHXXRatio - 1.0;
8343 dBrHXXRatio2 = 0.0;
8344 } else if (fstate == 7){
8345 BrHXXRatio = (myNPbase->BrHZZRatio());
8346 dBrHXXRatio1 = BrHXXRatio - 1.0;
8347 dBrHXXRatio2 = 0.0;
8348 } else {
8349 throw std::runtime_error("STXS12_ggH_pTH200_300 called with invalid argument for final state in fstate_i");
8350 }
8351
8352 //-- Production x Decay:
8353 if ((this->getModel()).isModelLinearized()){
8354 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
8355 } else if((this->getModel()).isModelNPquadratic()){
8356 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
8357 } else {
8358 return weight*(muProd)*(BrHXXRatio);
8359 }
8360
8361}
8362
8363
8364
8365// -----------------------------------------------------------------------------
8366
8367
8368//VM:STXS2024;
8369STXS12_ggH_pTH300_450::STXS12_ggH_pTH300_450(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8370: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8371{
8372 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8373 throw std::runtime_error("STXS12_ggH_pTH300_450 called with a class whose parent is not NPbase");
8374
8375}
8376
8378{
8379 //-- Production:
8380 double weight = 1.0; //If normalized to the SM
8381 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
8382 double muProd = myNPbase->STXS12_ggH_pTH300_450(sqrt_s);
8383 double muProd1 = muProd -1.0;
8384 double muProd2 = 0.0;
8385
8386 //-- Decay:
8387 double BrHXXRatio = 1.0;
8388 double dBrHXXRatio1 = 0.0;
8389 double dBrHXXRatio2 = 0.0;
8390 if (fstate==0){
8391 // Use for Cross-section [pb] with no Higgs-boson decay
8392 weight = 0.10632; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
8393 } else if (fstate == 1){
8394 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8395 dBrHXXRatio1 = BrHXXRatio - 1.0;
8396 dBrHXXRatio2 = 0.0;
8397 } else if (fstate == 2){
8398 BrHXXRatio = (myNPbase->BrHgagaRatio());
8399 dBrHXXRatio1 = BrHXXRatio - 1.0;
8400 dBrHXXRatio2 = 0.0;
8401 } else if (fstate == 3){
8402 BrHXXRatio = (myNPbase->BrHbbRatio());
8403 dBrHXXRatio1 = BrHXXRatio - 1.0;
8404 dBrHXXRatio2 = 0.0;
8405 } else if (fstate == 4){
8406 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8407 dBrHXXRatio1 = BrHXXRatio - 1.0;
8408 dBrHXXRatio2 = 0.0;
8409 } else if (fstate == 5){
8410 BrHXXRatio = (myNPbase->BrHtautauRatio());
8411 dBrHXXRatio1 = BrHXXRatio - 1.0;
8412 dBrHXXRatio2 = 0.0;
8413 } else if (fstate == 6){
8414 BrHXXRatio = (myNPbase->BrHWWRatio());
8415 dBrHXXRatio1 = BrHXXRatio - 1.0;
8416 dBrHXXRatio2 = 0.0;
8417 } else if (fstate == 7){
8418 BrHXXRatio = (myNPbase->BrHZZRatio());
8419 dBrHXXRatio1 = BrHXXRatio - 1.0;
8420 dBrHXXRatio2 = 0.0;
8421 } else {
8422 throw std::runtime_error("STXS12_ggH_pTH300_450 called with invalid argument for final state in fstate_i");
8423 }
8424
8425 //-- Production x Decay:
8426 if ((this->getModel()).isModelLinearized()){
8427 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
8428 } else if((this->getModel()).isModelNPquadratic()){
8429 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
8430 } else {
8431 return weight*(muProd)*(BrHXXRatio);
8432 }
8433
8434}
8435
8436
8437
8438
8439// -----------------------------------------------------------------------------
8440
8441
8442//VM:STXS2024;
8443STXS12_ggH_pTH450_650::STXS12_ggH_pTH450_650(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8444: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8445{
8446 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8447 throw std::runtime_error("STXS12_ggH_pTH450_650 called with a class whose parent is not NPbase");
8448
8449}
8450
8452{
8453 //-- Production:
8454 double weight = 1.0; //If normalized to the SM
8455 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
8456 double muProd = myNPbase->STXS12_ggH_pTH450_650(sqrt_s);
8457 double muProd1 = muProd -1.0;
8458 double muProd2 = 0.0;
8459
8460 //-- Decay:
8461 double BrHXXRatio = 1.0;
8462 double dBrHXXRatio1 = 0.0;
8463 double dBrHXXRatio2 = 0.0;
8464 if (fstate==0){
8465 // Use for Cross-section [pb] with no Higgs-boson decay
8466 weight = 1.; //Not available in Ref: https://www.hepdata.net/record/ins2104706 Figure7.
8467 } else if (fstate == 1){
8468 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8469 dBrHXXRatio1 = BrHXXRatio - 1.0;
8470 dBrHXXRatio2 = 0.0;
8471 } else if (fstate == 2){
8472 BrHXXRatio = (myNPbase->BrHgagaRatio());
8473 dBrHXXRatio1 = BrHXXRatio - 1.0;
8474 dBrHXXRatio2 = 0.0;
8475 } else if (fstate == 3){
8476 BrHXXRatio = (myNPbase->BrHbbRatio());
8477 dBrHXXRatio1 = BrHXXRatio - 1.0;
8478 dBrHXXRatio2 = 0.0;
8479 } else if (fstate == 4){
8480 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8481 dBrHXXRatio1 = BrHXXRatio - 1.0;
8482 dBrHXXRatio2 = 0.0;
8483 } else if (fstate == 5){
8484 BrHXXRatio = (myNPbase->BrHtautauRatio());
8485 dBrHXXRatio1 = BrHXXRatio - 1.0;
8486 dBrHXXRatio2 = 0.0;
8487 } else if (fstate == 6){
8488 BrHXXRatio = (myNPbase->BrHWWRatio());
8489 dBrHXXRatio1 = BrHXXRatio - 1.0;
8490 dBrHXXRatio2 = 0.0;
8491 } else if (fstate == 7){
8492 BrHXXRatio = (myNPbase->BrHZZRatio());
8493 dBrHXXRatio1 = BrHXXRatio - 1.0;
8494 dBrHXXRatio2 = 0.0;
8495 } else {
8496 throw std::runtime_error("STXS12_ggH_pTH450_Inf called with invalid argument for final state in fstate_i");
8497 }
8498
8499 //-- Production x Decay:
8500 if ((this->getModel()).isModelLinearized()){
8501 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
8502 } else if((this->getModel()).isModelNPquadratic()){
8503 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
8504 } else {
8505 return weight*(muProd)*(BrHXXRatio);
8506 }
8507
8508}
8509
8510
8511
8512// -----------------------------------------------------------------------------
8513
8514
8515//VM:STXS2024;
8516STXS12_ggH_pTH650_Inf::STXS12_ggH_pTH650_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8517: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8518{
8519 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8520 throw std::runtime_error("STXS12_ggH_pTH650_Inf called with a class whose parent is not NPbase");
8521
8522}
8523
8525{
8526 //-- Production:
8527 double weight = 1.0; //If normalized to the SM
8528 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
8529 double muProd = myNPbase->STXS12_ggH_pTH650_Inf(sqrt_s);
8530 double muProd1 = muProd -1.0;
8531 double muProd2 = 0.0;
8532
8533 //-- Decay:
8534 double BrHXXRatio = 1.0;
8535 double dBrHXXRatio1 = 0.0;
8536 double dBrHXXRatio2 = 0.0;
8537 if (fstate==0){
8538 // Use for Cross-section [pb] with no Higgs-boson decay
8539 weight = 1.; //Not available in Ref: https://www.hepdata.net/record/ins2104706 Figure7.
8540 } else if (fstate == 1){
8541 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8542 dBrHXXRatio1 = BrHXXRatio - 1.0;
8543 dBrHXXRatio2 = 0.0;
8544 } else if (fstate == 2){
8545 BrHXXRatio = (myNPbase->BrHgagaRatio());
8546 dBrHXXRatio1 = BrHXXRatio - 1.0;
8547 dBrHXXRatio2 = 0.0;
8548 } else if (fstate == 3){
8549 BrHXXRatio = (myNPbase->BrHbbRatio());
8550 dBrHXXRatio1 = BrHXXRatio - 1.0;
8551 dBrHXXRatio2 = 0.0;
8552 } else if (fstate == 4){
8553 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8554 dBrHXXRatio1 = BrHXXRatio - 1.0;
8555 dBrHXXRatio2 = 0.0;
8556 } else if (fstate == 5){
8557 BrHXXRatio = (myNPbase->BrHtautauRatio());
8558 dBrHXXRatio1 = BrHXXRatio - 1.0;
8559 dBrHXXRatio2 = 0.0;
8560 } else if (fstate == 6){
8561 BrHXXRatio = (myNPbase->BrHWWRatio());
8562 dBrHXXRatio1 = BrHXXRatio - 1.0;
8563 dBrHXXRatio2 = 0.0;
8564 } else if (fstate == 7){
8565 BrHXXRatio = (myNPbase->BrHZZRatio());
8566 dBrHXXRatio1 = BrHXXRatio - 1.0;
8567 dBrHXXRatio2 = 0.0;
8568 } else {
8569 throw std::runtime_error("STXS12_ggH_pTH450_Inf called with invalid argument for final state in fstate_i");
8570 }
8571
8572 //-- Production x Decay:
8573 if ((this->getModel()).isModelLinearized()){
8574 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
8575 } else if((this->getModel()).isModelNPquadratic()){
8576 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
8577 } else {
8578 return weight*(muProd)*(BrHXXRatio);
8579 }
8580
8581}
8582
8583
8584
8585// -----------------------------------------------------------------------------
8586
8587
8588//VM:STXS2024;
8589STXS12_ggH_pTH450_Inf::STXS12_ggH_pTH450_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8590: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8591{
8592 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8593 throw std::runtime_error("STXS12_ggH_pTH450_Inf called with a class whose parent is not NPbase");
8594
8595}
8596
8598{
8599 //-- Production:
8600 double weight = 1.0; //If normalized to the SM
8601 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
8602 double muProd = myNPbase->STXS12_ggH_pTH450_Inf(sqrt_s);
8603 double muProd1 = muProd -1.0;
8604 double muProd2 = 0.0;
8605
8606 //-- Decay:
8607 double BrHXXRatio = 1.0;
8608 double dBrHXXRatio1 = 0.0;
8609 double dBrHXXRatio2 = 0.0;
8610 if (fstate==0){
8611 // Use for Cross-section [pb] with no Higgs-boson decay
8612 weight = 0.017974; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
8613 } else if (fstate == 1){
8614 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8615 dBrHXXRatio1 = BrHXXRatio - 1.0;
8616 dBrHXXRatio2 = 0.0;
8617 } else if (fstate == 2){
8618 BrHXXRatio = (myNPbase->BrHgagaRatio());
8619 dBrHXXRatio1 = BrHXXRatio - 1.0;
8620 dBrHXXRatio2 = 0.0;
8621 } else if (fstate == 3){
8622 BrHXXRatio = (myNPbase->BrHbbRatio());
8623 dBrHXXRatio1 = BrHXXRatio - 1.0;
8624 dBrHXXRatio2 = 0.0;
8625 } else if (fstate == 4){
8626 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8627 dBrHXXRatio1 = BrHXXRatio - 1.0;
8628 dBrHXXRatio2 = 0.0;
8629 } else if (fstate == 5){
8630 BrHXXRatio = (myNPbase->BrHtautauRatio());
8631 dBrHXXRatio1 = BrHXXRatio - 1.0;
8632 dBrHXXRatio2 = 0.0;
8633 } else if (fstate == 6){
8634 BrHXXRatio = (myNPbase->BrHWWRatio());
8635 dBrHXXRatio1 = BrHXXRatio - 1.0;
8636 dBrHXXRatio2 = 0.0;
8637 } else if (fstate == 7){
8638 BrHXXRatio = (myNPbase->BrHZZRatio());
8639 dBrHXXRatio1 = BrHXXRatio - 1.0;
8640 dBrHXXRatio2 = 0.0;
8641 } else {
8642 throw std::runtime_error("STXS12_ggH_pTH450_Inf called with invalid argument for final state in fstate_i");
8643 }
8644
8645 //-- Production x Decay:
8646 if ((this->getModel()).isModelLinearized()){
8647 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
8648 } else if((this->getModel()).isModelNPquadratic()){
8649 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
8650 } else {
8651 return weight*(muProd)*(BrHXXRatio);
8652 }
8653
8654}
8655
8656
8657// -----------------------------------------------------------------------------
8658
8659STXS12_ggHll_pTV0_75::STXS12_ggHll_pTV0_75(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8660: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8661{
8662 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8663 throw std::runtime_error("STXS12_ggHll_pTV0_75 called with a class whose parent is not NPbase");
8664
8665}
8666
8668{
8669 double BrHXXRatio = 1.0;
8670 if (fstate == 1){
8671 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8672 } else if (fstate == 2){
8673 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
8674 } else if (fstate == 3){
8675 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
8676 } else if (fstate == 4){
8677 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8678 } else {
8679 throw std::runtime_error("STXS12_ggHll_pTV0_75 called with invalid argument for final state in fstate_i");
8680 }
8681
8682 if ((this->getModel()).isModelLinearized()) {
8683 return ((myNPbase->STXS12_ggHll_pTV0_75(sqrt_s)) + (BrHXXRatio) - 1.0);
8684 } else {
8685 return (myNPbase->STXS12_ggHll_pTV0_75(sqrt_s))*(BrHXXRatio);
8686 }
8687}
8688
8689// -----------------------------------------------------------------------------
8690
8691STXS12_ggHll_pTV75_150::STXS12_ggHll_pTV75_150(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8692: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8693{
8694 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8695 throw std::runtime_error("STXS12_ggHll_pTV75_150 called with a class whose parent is not NPbase");
8696
8697}
8698
8700{
8701 double BrHXXRatio = 1.0;
8702 if (fstate == 1){
8703 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8704 } else if (fstate == 2){
8705 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
8706 } else if (fstate == 3){
8707 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
8708 } else if (fstate == 4){
8709 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8710 } else {
8711 throw std::runtime_error("STXS12_ggHll_pTV75_150 called with invalid argument for final state in fstate_i");
8712 }
8713
8714 if ((this->getModel()).isModelLinearized()) {
8715 return ((myNPbase->STXS12_ggHll_pTV75_150(sqrt_s)) + (BrHXXRatio) - 1.0);
8716 } else {
8717 return (myNPbase->STXS12_ggHll_pTV75_150(sqrt_s))*(BrHXXRatio);
8718 }
8719}
8720
8721// -----------------------------------------------------------------------------
8722
8723STXS12_ggHll_pTV150_250_Nj0::STXS12_ggHll_pTV150_250_Nj0(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8724: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8725{
8726 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8727 throw std::runtime_error("STXS12_ggHll_pTV150_250_Nj0 called with a class whose parent is not NPbase");
8728
8729}
8730
8732{
8733 double BrHXXRatio = 1.0;
8734 if (fstate == 1){
8735 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8736 } else if (fstate == 2){
8737 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
8738 } else if (fstate == 3){
8739 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
8740 } else if (fstate == 4){
8741 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8742 } else {
8743 throw std::runtime_error("STXS12_ggHll_pTV150_250_Nj0 called with invalid argument for final state in fstate_i");
8744 }
8745
8746 if ((this->getModel()).isModelLinearized()) {
8747 return ((myNPbase->STXS12_ggHll_pTV150_250_Nj0(sqrt_s)) + (BrHXXRatio) - 1.0);
8748 } else {
8749 return (myNPbase->STXS12_ggHll_pTV150_250_Nj0(sqrt_s))*(BrHXXRatio);
8750 }
8751}
8752
8753// -----------------------------------------------------------------------------
8754
8755STXS12_ggHll_pTV150_250_Nj1::STXS12_ggHll_pTV150_250_Nj1(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8756: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8757{
8758 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8759 throw std::runtime_error("STXS12_ggHll_pTV150_250_Nj1 called with a class whose parent is not NPbase");
8760
8761}
8762
8764{
8765 double BrHXXRatio = 1.0;
8766 if (fstate == 1){
8767 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8768 } else if (fstate == 2){
8769 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
8770 } else if (fstate == 3){
8771 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
8772 } else if (fstate == 4){
8773 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8774 } else {
8775 throw std::runtime_error("STXS12_ggHll_pTV150_250_Nj1 called with invalid argument for final state in fstate_i");
8776 }
8777
8778 if ((this->getModel()).isModelLinearized()) {
8779 return ((myNPbase->STXS12_ggHll_pTV150_250_Nj1(sqrt_s)) + (BrHXXRatio) - 1.0);
8780 } else {
8781 return (myNPbase->STXS12_ggHll_pTV150_250_Nj1(sqrt_s))*(BrHXXRatio);
8782 }
8783}
8784
8785// -----------------------------------------------------------------------------
8786
8787STXS12_ggHll_pTV250_Inf::STXS12_ggHll_pTV250_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8788: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8789{
8790 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8791 throw std::runtime_error("STXS12_ggHll_pTV250_Inf called with a class whose parent is not NPbase");
8792
8793}
8794
8796{
8797 double BrHXXRatio = 1.0;
8798 if (fstate == 1){
8799 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8800 } else if (fstate == 2){
8801 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
8802 } else if (fstate == 3){
8803 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
8804 } else if (fstate == 4){
8805 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8806 } else {
8807 throw std::runtime_error("STXS12_ggHll_pTV250_Inf called with invalid argument for final state in fstate_i");
8808 }
8809
8810 if ((this->getModel()).isModelLinearized()) {
8811 return ((myNPbase->STXS12_ggHll_pTV250_Inf(sqrt_s)) + (BrHXXRatio) - 1.0);
8812 } else {
8813 return (myNPbase->STXS12_ggHll_pTV250_Inf(sqrt_s))*(BrHXXRatio);
8814 }
8815}
8816
8817// -----------------------------------------------------------------------------
8818
8819STXS12_qqHqq_Nj0::STXS12_qqHqq_Nj0(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8820: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8821{
8822 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8823 throw std::runtime_error("STXS12_qqHqq_Nj0 called with a class whose parent is not NPbase");
8824
8825}
8826
8828{
8829 double BrHXXRatio = 1.0;
8830 if (fstate == 1){
8831 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8832 } else if (fstate == 2){
8833 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
8834 } else if (fstate == 3){
8835 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
8836 } else if (fstate == 4){
8837 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8838 } else {
8839 throw std::runtime_error("STXS12_qqHqq_Nj called with invalid argument for final state in fstate_i");
8840 }
8841
8842 if ((this->getModel()).isModelLinearized()) {
8843 return ((myNPbase->STXS12_qqHqq_Nj0(sqrt_s)) + (BrHXXRatio) - 1.0);
8844 } else {
8845 return (myNPbase->STXS12_qqHqq_Nj0(sqrt_s))*(BrHXXRatio);
8846 }
8847}
8848
8849// -----------------------------------------------------------------------------
8850
8851STXS12_qqHqq_Nj1::STXS12_qqHqq_Nj1(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8852: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8853{
8854 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8855 throw std::runtime_error("STXS12_qqHqq_Nj1 called with a class whose parent is not NPbase");
8856
8857}
8858
8860{
8861 double BrHXXRatio = 1.0;
8862 if (fstate == 1){
8863 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8864 } else if (fstate == 2){
8865 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
8866 } else if (fstate == 3){
8867 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
8868 } else if (fstate == 4){
8869 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8870 } else {
8871 throw std::runtime_error("STXS12_qqHqq_Nj1 called with invalid argument for final state in fstate_i");
8872 }
8873
8874 if ((this->getModel()).isModelLinearized()) {
8875 return ((myNPbase->STXS12_qqHqq_Nj1(sqrt_s)) + (BrHXXRatio) - 1.0);
8876 } else {
8877 return (myNPbase->STXS12_qqHqq_Nj1(sqrt_s))*(BrHXXRatio);
8878 }
8879}
8880
8881// -----------------------------------------------------------------------------
8882
8883STXS12_qqHqq_mjj0_60_Nj2::STXS12_qqHqq_mjj0_60_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8884: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8885{
8886 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8887 throw std::runtime_error("STXS12_qqHqq_mjj0_60_Nj2 called with a class whose parent is not NPbase");
8888
8889}
8890
8892{
8893 double BrHXXRatio = 1.0;
8894 if (fstate == 1){
8895 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8896 } else if (fstate == 2){
8897 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
8898 } else if (fstate == 3){
8899 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
8900 } else if (fstate == 4){
8901 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8902 } else {
8903 throw std::runtime_error("STXS12_qqHqq_mjj0_60_Nj2 called with invalid argument for final state in fstate_i");
8904 }
8905
8906 if ((this->getModel()).isModelLinearized()) {
8907 return ((myNPbase->STXS12_qqHqq_mjj0_60_Nj2(sqrt_s)) + (BrHXXRatio) - 1.0);
8908 } else {
8909 return (myNPbase->STXS12_qqHqq_mjj0_60_Nj2(sqrt_s))*(BrHXXRatio);
8910 }
8911}
8912
8913
8914
8915// -----------------------------------------------------------------------------
8916
8917
8918//VM:STXS2024;
8919STXS12_qqHqq_VH_veto_Nj01::STXS12_qqHqq_VH_veto_Nj01(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8920: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8921{
8922 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8923 throw std::runtime_error("STXS12_qqHqq_VH_veto_Nj01 called with a class whose parent is not NPbase");
8924
8925}
8926
8928{
8929 //-- Production:
8930 double weight = 1.0; //If normalized to the SM
8931 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
8932 double muProd = myNPbase->STXS12_qqHqq_VH_veto_Nj01(sqrt_s);
8933 double muProd1 = muProd -1.0;
8934 double muProd2 = 0.0;
8935
8936 //-- Decay:
8937 double BrHXXRatio = 1.0;
8938 double dBrHXXRatio1 = 0.0;
8939 double dBrHXXRatio2 = 0.0;
8940 if (fstate==0){
8941 // Use for Cross-section [pb] with no Higgs-boson decay
8942 weight = (1.); //Not available in Ref: https://www.hepdata.net/record/ins2104706 Figure7.
8943 } else if (fstate == 1){
8944 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
8945 dBrHXXRatio1 = BrHXXRatio - 1.0;
8946 dBrHXXRatio2 = 0.0;
8947 } else if (fstate == 2){
8948 BrHXXRatio = (myNPbase->BrHgagaRatio());
8949 dBrHXXRatio1 = BrHXXRatio - 1.0;
8950 dBrHXXRatio2 = 0.0;
8951 } else if (fstate == 3){
8952 BrHXXRatio = (myNPbase->BrHbbRatio());
8953 dBrHXXRatio1 = BrHXXRatio - 1.0;
8954 dBrHXXRatio2 = 0.0;
8955 } else if (fstate == 4){
8956 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
8957 dBrHXXRatio1 = BrHXXRatio - 1.0;
8958 dBrHXXRatio2 = 0.0;
8959 } else if (fstate == 5){
8960 BrHXXRatio = (myNPbase->BrHtautauRatio());
8961 dBrHXXRatio1 = BrHXXRatio - 1.0;
8962 dBrHXXRatio2 = 0.0;
8963 } else if (fstate == 6){
8964 BrHXXRatio = (myNPbase->BrHWWRatio());
8965 dBrHXXRatio1 = BrHXXRatio - 1.0;
8966 dBrHXXRatio2 = 0.0;
8967 } else if (fstate == 7){
8968 BrHXXRatio = (myNPbase->BrHZZRatio());
8969 dBrHXXRatio1 = BrHXXRatio - 1.0;
8970 dBrHXXRatio2 = 0.0;
8971 } else {
8972 throw std::runtime_error("STXS12_ggH_pTH200_300 called with invalid argument for final state in fstate_i");
8973 }
8974
8975 //-- Production x Decay:
8976 if ((this->getModel()).isModelLinearized()){
8977 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
8978 } else if((this->getModel()).isModelNPquadratic()){
8979 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
8980 } else {
8981 return weight*(muProd)*(BrHXXRatio);
8982 }
8983
8984}
8985
8986
8987
8988
8989// -----------------------------------------------------------------------------
8990
8991
8992//VM:STXS2024;
8993STXS12_qqHqq_VH_had_Nj2::STXS12_qqHqq_VH_had_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
8994: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8995{
8996 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
8997 throw std::runtime_error("STXS12_qqHqq_VH_had_Nj2 called with a class whose parent is not NPbase");
8998
8999}
9000
9002{
9003 //-- Production:
9004 double weight = 1.0; //If normalized to the SM
9005 //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
9006 double muProd = myNPbase->STXS12_qqHqq_VH_had_Nj2(sqrt_s);
9007 double muProd1 = muProd -1.0;
9008 double muProd2 = 0.0;
9009
9010 //-- Decay:
9011 double BrHXXRatio = 1.0;
9012 double dBrHXXRatio1 = 0.0;
9013 double dBrHXXRatio2 = 0.0;
9014 if (fstate==0){
9015 // Use for Cross-section [pb] with no Higgs-boson decay
9016 weight = (1.); //Not available in Ref: https://www.hepdata.net/record/ins2104706 Figure7.
9017 } else if (fstate == 1){
9018 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9019 dBrHXXRatio1 = BrHXXRatio - 1.0;
9020 dBrHXXRatio2 = 0.0;
9021 } else if (fstate == 2){
9022 BrHXXRatio = (myNPbase->BrHgagaRatio());
9023 dBrHXXRatio1 = BrHXXRatio - 1.0;
9024 dBrHXXRatio2 = 0.0;
9025 } else if (fstate == 3){
9026 BrHXXRatio = (myNPbase->BrHbbRatio());
9027 dBrHXXRatio1 = BrHXXRatio - 1.0;
9028 dBrHXXRatio2 = 0.0;
9029 } else if (fstate == 4){
9030 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9031 dBrHXXRatio1 = BrHXXRatio - 1.0;
9032 dBrHXXRatio2 = 0.0;
9033 } else if (fstate == 5){
9034 BrHXXRatio = (myNPbase->BrHtautauRatio());
9035 dBrHXXRatio1 = BrHXXRatio - 1.0;
9036 dBrHXXRatio2 = 0.0;
9037 } else if (fstate == 6){
9038 BrHXXRatio = (myNPbase->BrHWWRatio());
9039 dBrHXXRatio1 = BrHXXRatio - 1.0;
9040 dBrHXXRatio2 = 0.0;
9041 } else if (fstate == 7){
9042 BrHXXRatio = (myNPbase->BrHZZRatio());
9043 dBrHXXRatio1 = BrHXXRatio - 1.0;
9044 dBrHXXRatio2 = 0.0;
9045 } else {
9046 throw std::runtime_error("STXS12_ggH_pTH200_300 called with invalid argument for final state in fstate_i");
9047 }
9048
9049 //-- Production x Decay:
9050 if ((this->getModel()).isModelLinearized()){
9051 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9052 } else if((this->getModel()).isModelNPquadratic()){
9053 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9054 } else {
9055 return weight*(muProd)*(BrHXXRatio);
9056 }
9057
9058}
9059
9060
9061
9062// -----------------------------------------------------------------------------
9063
9064//AG:STXS2024
9065STXS12_qqHqq_mjj60_120_Nj2::STXS12_qqHqq_mjj60_120_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
9066: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9067{
9068 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9069 throw std::runtime_error("STXS12_qqHqq_mjj60_120_Nj2 called with a class whose parent is not NPbase");
9070
9071}
9072
9074{
9075 //-- Production:
9076 double weight = 1.0; //If normalized to the SM
9077 double muProd = myNPbase->STXS12_qqHqq_mjj60_120_Nj2(sqrt_s);
9078 double muProd1 = muProd -1.0;
9079 double muProd2 = 0.0;
9080
9081 //-- Decay:
9082 double BrHXXRatio = 1.0;
9083 double dBrHXXRatio1 = 0.0;
9084 double dBrHXXRatio2 = 0.0;
9085 if (fstate==0){
9086 // Use for Cross-section [pb] with no Higgs-boson decay
9087 weight = 1.0; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
9088 } else if (fstate == 1){
9089 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9090 dBrHXXRatio1 = BrHXXRatio - 1.0;
9091 dBrHXXRatio2 = 0.0;
9092 } else if (fstate == 2){
9093 BrHXXRatio = (myNPbase->BrHgagaRatio());
9094 dBrHXXRatio1 = BrHXXRatio - 1.0;
9095 dBrHXXRatio2 = 0.0;
9096 } else if (fstate == 3){
9097 BrHXXRatio = (myNPbase->BrHbbRatio());
9098 dBrHXXRatio1 = BrHXXRatio - 1.0;
9099 dBrHXXRatio2 = 0.0;
9100 } else if (fstate == 4){
9101 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9102 dBrHXXRatio1 = BrHXXRatio - 1.0;
9103 dBrHXXRatio2 = 0.0;
9104 } else if (fstate == 5){
9105 BrHXXRatio = (myNPbase->BrHtautauRatio());
9106 dBrHXXRatio1 = BrHXXRatio - 1.0;
9107 dBrHXXRatio2 = 0.0;
9108 } else if (fstate == 6){
9109 BrHXXRatio = (myNPbase->BrHWWRatio());
9110 dBrHXXRatio1 = BrHXXRatio - 1.0;
9111 dBrHXXRatio2 = 0.0;
9112 } else if (fstate == 7){
9113 BrHXXRatio = (myNPbase->BrHZZRatio());
9114 dBrHXXRatio1 = BrHXXRatio - 1.0;
9115 dBrHXXRatio2 = 0.0;
9116 } else {
9117 throw std::runtime_error("STXS12_qqHqq_mjj60_120_Nj2 called with invalid argument for final state in fstate_i");
9118 }
9119
9120 //-- Production x Decay:
9121 if ((this->getModel()).isModelLinearized()){
9122 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9123 } else if((this->getModel()).isModelNPquadratic()){
9124 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9125 } else {
9126 return weight*(muProd)*(BrHXXRatio);
9127 }
9128}
9129
9130// -----------------------------------------------------------------------------
9131
9132STXS12_qqHqq_mjj120_350_Nj2::STXS12_qqHqq_mjj120_350_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
9133: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9134{
9135 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9136 throw std::runtime_error("STXS12_qqHqq_mjj120_350_Nj2 called with a class whose parent is not NPbase");
9137
9138}
9139
9141{
9142 double BrHXXRatio = 1.0;
9143 if (fstate == 1){
9144 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9145 } else if (fstate == 2){
9146 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
9147 } else if (fstate == 3){
9148 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
9149 } else if (fstate == 4){
9150 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9151 } else {
9152 throw std::runtime_error("STXS12_qqHqq_mjj120_350_Nj2 called with invalid argument for final state in fstate_i");
9153 }
9154
9155 if ((this->getModel()).isModelLinearized()) {
9156 return ((myNPbase->STXS12_qqHqq_mjj120_350_Nj2(sqrt_s)) + (BrHXXRatio) - 1.0);
9157 } else {
9158 return (myNPbase->STXS12_qqHqq_mjj120_350_Nj2(sqrt_s))*(BrHXXRatio);
9159 }
9160}
9161
9162// -----------------------------------------------------------------------------
9163
9164//AG:STXS2024
9166: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9167{
9168 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9169 throw std::runtime_error("STXS12_qqHqq_mjj350_Inf_pTH200_Inf_Nj2 called with a class whose parent is not NPbase");
9170
9171}
9172
9174{
9175 //-- Production:
9176 double weight = 1.0; //If normalized to the SM
9178 double muProd1 = muProd -1.0;
9179 double muProd2 = 0.0;
9180
9181 //-- Decay:
9182 double BrHXXRatio = 1.0;
9183 double dBrHXXRatio1 = 0.0;
9184 double dBrHXXRatio2 = 0.0;
9185 if (fstate==0){
9186 // Use for Cross-section [pb] with no Higgs-boson decay
9187 weight = 1.0; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
9188 } else if (fstate == 1){
9189 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9190 dBrHXXRatio1 = BrHXXRatio - 1.0;
9191 dBrHXXRatio2 = 0.0;
9192 } else if (fstate == 2){
9193 BrHXXRatio = (myNPbase->BrHgagaRatio());
9194 dBrHXXRatio1 = BrHXXRatio - 1.0;
9195 dBrHXXRatio2 = 0.0;
9196 } else if (fstate == 3){
9197 BrHXXRatio = (myNPbase->BrHbbRatio());
9198 dBrHXXRatio1 = BrHXXRatio - 1.0;
9199 dBrHXXRatio2 = 0.0;
9200 } else if (fstate == 4){
9201 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9202 dBrHXXRatio1 = BrHXXRatio - 1.0;
9203 dBrHXXRatio2 = 0.0;
9204 } else if (fstate == 5){
9205 BrHXXRatio = (myNPbase->BrHtautauRatio());
9206 dBrHXXRatio1 = BrHXXRatio - 1.0;
9207 dBrHXXRatio2 = 0.0;
9208 } else if (fstate == 6){
9209 BrHXXRatio = (myNPbase->BrHWWRatio());
9210 dBrHXXRatio1 = BrHXXRatio - 1.0;
9211 dBrHXXRatio2 = 0.0;
9212 } else if (fstate == 7){
9213 BrHXXRatio = (myNPbase->BrHZZRatio());
9214 dBrHXXRatio1 = BrHXXRatio - 1.0;
9215 dBrHXXRatio2 = 0.0;
9216 } else {
9217 throw std::runtime_error("STXS12_qqHqq_mjj350_Inf_pTH200_Inf_Nj2 called with invalid argument for final state in fstate_i");
9218 }
9219
9220
9221 //-- Production x Decay:
9222 if ((this->getModel()).isModelLinearized()){
9223 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9224 } else if((this->getModel()).isModelNPquadratic()){
9225 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9226 } else {
9227 return weight*(muProd)*(BrHXXRatio);
9228 }
9229
9230}
9231
9232// -----------------------------------------------------------------------------
9233
9235: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9236{
9237 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9238 throw std::runtime_error("STXS12_qqHqq_mjj350_700_pTH0_200_pTHjj0_25_Nj2 called with a class whose parent is not NPbase");
9239
9240}
9241
9243{
9244 double BrHXXRatio = 1.0;
9245 if (fstate == 1){
9246 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9247 } else if (fstate == 2){
9248 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
9249 } else if (fstate == 3){
9250 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
9251 } else if (fstate == 4){
9252 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9253 } else {
9254 throw std::runtime_error("STXS12_qqHqq_mjj350_700_pTH0_200_pTHjj0_25_Nj2 called with invalid argument for final state in fstate_i");
9255 }
9256
9257 if ((this->getModel()).isModelLinearized()) {
9258 return ((myNPbase->STXS12_qqHqq_mjj350_700_pTH0_200_pTHjj0_25_Nj2(sqrt_s)) + (BrHXXRatio) - 1.0);
9259 } else {
9261 }
9262}
9263
9264// -----------------------------------------------------------------------------
9265
9267: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9268{
9269 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9270 throw std::runtime_error("STXS12_qqHqq_mjj350_700_pTH0_200_pTHjj25_Inf_Nj2 called with a class whose parent is not NPbase");
9271
9272}
9273
9275{
9276 double BrHXXRatio = 1.0;
9277 if (fstate == 1){
9278 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9279 } else if (fstate == 2){
9280 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
9281 } else if (fstate == 3){
9282 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
9283 } else if (fstate == 4){
9284 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9285 } else {
9286 throw std::runtime_error("STXS12_qqHqq_mjj350_700_pTH0_200_pTHjj25_Inf_Nj2 called with invalid argument for final state in fstate_i");
9287 }
9288
9289 if ((this->getModel()).isModelLinearized()) {
9290 return ((myNPbase->STXS12_qqHqq_mjj350_700_pTH0_200_pTHjj25_Inf_Nj2(sqrt_s)) + (BrHXXRatio) - 1.0);
9291 } else {
9293 }
9294}
9295
9296// -----------------------------------------------------------------------------
9297
9299: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9300{
9301 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9302 throw std::runtime_error("STXS12_qqHqq_mjj700_Inf_pTH0_200_pTHjj0_25_Nj2 called with a class whose parent is not NPbase");
9303
9304}
9305
9307{
9308 double BrHXXRatio = 1.0;
9309 if (fstate == 1){
9310 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9311 } else if (fstate == 2){
9312 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
9313 } else if (fstate == 3){
9314 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
9315 } else if (fstate == 4){
9316 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9317 } else {
9318 throw std::runtime_error("STXS12_qqHqq_mjj700_Inf_pTH0_200_pTHjj0_25_Nj2 called with invalid argument for final state in fstate_i");
9319 }
9320
9321 if ((this->getModel()).isModelLinearized()) {
9322 return ((myNPbase->STXS12_qqHqq_mjj700_Inf_pTH0_200_pTHjj0_25_Nj2(sqrt_s)) + (BrHXXRatio) - 1.0);
9323 } else {
9325 }
9326}
9327
9328// -----------------------------------------------------------------------------
9329
9331: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9332{
9333 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9334 throw std::runtime_error("STXS12_qqHqq_mjj700_Inf_pTH0_200_pTHjj25_Inf_Nj2 called with a class whose parent is not NPbase");
9335
9336}
9337
9339{
9340 double BrHXXRatio = 1.0;
9341 if (fstate == 1){
9342 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9343 } else if (fstate == 2){
9344 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
9345 } else if (fstate == 3){
9346 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
9347 } else if (fstate == 4){
9348 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9349 } else {
9350 throw std::runtime_error("STXS12_qqHqq_mjj700_Inf_pTH0_200_pTHjj25_Inf_Nj2 called with invalid argument for final state in fstate_i");
9351 }
9352
9353 if ((this->getModel()).isModelLinearized()) {
9354 return ((myNPbase->STXS12_qqHqq_mjj700_Inf_pTH0_200_pTHjj25_Inf_Nj2(sqrt_s)) + (BrHXXRatio) - 1.0);
9355 } else {
9357 }
9358}
9359
9360// -----------------------------------------------------------------------------
9361
9362//AG:STXS2024
9363STXS12_qqHqq_mjj350_700_pTH0_200_Nj2::STXS12_qqHqq_mjj350_700_pTH0_200_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
9364: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9365{
9366 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9367 throw std::runtime_error("STXS12_qqHqq_mjj350_700_pTH0_200_Nj2 called with a class whose parent is not NPbase");
9368
9369}
9370
9372{
9373 //-- Production:
9374 double weight = 1.0; //If normalized to the SM
9376 double muProd1 = muProd -1.0;
9377 double muProd2 = 0.0;
9378
9379 //-- Decay:
9380 double BrHXXRatio = 1.0;
9381 double dBrHXXRatio1 = 0.0;
9382 double dBrHXXRatio2 = 0.0;
9383 if (fstate==0){
9384 // Use for Cross-section [pb] with no Higgs-boson decay
9385 weight = 0.53537; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
9386 } else if (fstate == 1){
9387 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9388 dBrHXXRatio1 = BrHXXRatio - 1.0;
9389 dBrHXXRatio2 = 0.0;
9390 } else if (fstate == 2){
9391 BrHXXRatio = (myNPbase->BrHgagaRatio());
9392 dBrHXXRatio1 = BrHXXRatio - 1.0;
9393 dBrHXXRatio2 = 0.0;
9394 } else if (fstate == 3){
9395 BrHXXRatio = (myNPbase->BrHbbRatio());
9396 dBrHXXRatio1 = BrHXXRatio - 1.0;
9397 dBrHXXRatio2 = 0.0;
9398 } else if (fstate == 4){
9399 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9400 dBrHXXRatio1 = BrHXXRatio - 1.0;
9401 dBrHXXRatio2 = 0.0;
9402 } else if (fstate == 5){
9403 BrHXXRatio = (myNPbase->BrHtautauRatio());
9404 dBrHXXRatio1 = BrHXXRatio - 1.0;
9405 dBrHXXRatio2 = 0.0;
9406 } else if (fstate == 6){
9407 BrHXXRatio = (myNPbase->BrHWWRatio());
9408 dBrHXXRatio1 = BrHXXRatio - 1.0;
9409 dBrHXXRatio2 = 0.0;
9410 } else {
9411 throw std::runtime_error("STXS12_qqHqq_mjj350_700_pTH0_200_Nj2 called with invalid argument for final state in fstate_i");
9412 }
9413
9414 //-- Production x Decay:
9415 if ((this->getModel()).isModelLinearized()){
9416 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9417 } else if((this->getModel()).isModelNPquadratic()){
9418 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9419 } else {
9420 return weight*(muProd)*(BrHXXRatio);
9421 }
9422
9423
9424}
9425
9426// -----------------------------------------------------------------------------
9427
9428//AG:STXS2024
9429STXS12_qqHqq_mjj700_1000_pTH0_200_Nj2::STXS12_qqHqq_mjj700_1000_pTH0_200_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
9430: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9431{
9432 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9433 throw std::runtime_error("STXS12_qqHqq_mjj700_1000_pTH0_200_Nj2 called with a class whose parent is not NPbase");
9434
9435}
9436
9438{
9439 //-- Production:
9440 double weight = 1.0; //If normalized to the SM
9442 double muProd1 = muProd -1.0;
9443 double muProd2 = 0.0;
9444
9445 //-- Decay:
9446 double BrHXXRatio = 1.0;
9447 double dBrHXXRatio1 = 0.0;
9448 double dBrHXXRatio2 = 0.0;
9449 if (fstate==0){
9450 // Use for Cross-section [pb] with no Higgs-boson decay
9451 weight = 0.25614; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
9452 } else if (fstate == 1){
9453 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9454 dBrHXXRatio1 = BrHXXRatio - 1.0;
9455 dBrHXXRatio2 = 0.0;
9456 } else if (fstate == 2){
9457 BrHXXRatio = (myNPbase->BrHgagaRatio());
9458 dBrHXXRatio1 = BrHXXRatio - 1.0;
9459 dBrHXXRatio2 = 0.0;
9460 } else if (fstate == 3){
9461 BrHXXRatio = (myNPbase->BrHbbRatio());
9462 dBrHXXRatio1 = BrHXXRatio - 1.0;
9463 dBrHXXRatio2 = 0.0;
9464 } else if (fstate == 4){
9465 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9466 dBrHXXRatio1 = BrHXXRatio - 1.0;
9467 dBrHXXRatio2 = 0.0;
9468 } else if (fstate == 5){
9469 BrHXXRatio = (myNPbase->BrHtautauRatio());
9470 dBrHXXRatio1 = BrHXXRatio - 1.0;
9471 dBrHXXRatio2 = 0.0;
9472 } else if (fstate == 6){
9473 BrHXXRatio = (myNPbase->BrHWWRatio());
9474 dBrHXXRatio1 = BrHXXRatio - 1.0;
9475 dBrHXXRatio2 = 0.0;
9476 } else {
9477 throw std::runtime_error("STXS12_qqHqq_mjj700_1000_pTH0_200_Nj2 called with invalid argument for final state in fstate_i");
9478 }
9479
9480 //-- Production x Decay:
9481 if ((this->getModel()).isModelLinearized()){
9482 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9483 } else if((this->getModel()).isModelNPquadratic()){
9484 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9485 } else {
9486 return weight*(muProd)*(BrHXXRatio);
9487 }
9488
9489
9490}
9491
9492// -----------------------------------------------------------------------------
9493
9494//AG:STXS2024
9495STXS12_qqHqq_mjj1000_1500_pTH0_200_Nj2::STXS12_qqHqq_mjj1000_1500_pTH0_200_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
9496: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9497{
9498 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9499 throw std::runtime_error("STXS12_qqHqq_mjj1000_1500_pTH0_200_Nj2 called with a class whose parent is not NPbase");
9500
9501}
9502
9504{
9505 //-- Production:
9506 double weight = 1.0; //If normalized to the SM
9508 double muProd1 = muProd -1.0;
9509 double muProd2 = 0.0;
9510
9511 //-- Decay:
9512 double BrHXXRatio = 1.0;
9513 double dBrHXXRatio1 = 0.0;
9514 double dBrHXXRatio2 = 0.0;
9515 if (fstate==0){
9516 // Use for Cross-section [pb] with no Higgs-boson decay
9517 weight = 0.22408; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
9518 } else if (fstate == 1){
9519 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9520 dBrHXXRatio1 = BrHXXRatio - 1.0;
9521 dBrHXXRatio2 = 0.0;
9522 } else if (fstate == 2){
9523 BrHXXRatio = (myNPbase->BrHgagaRatio());
9524 dBrHXXRatio1 = BrHXXRatio - 1.0;
9525 dBrHXXRatio2 = 0.0;
9526 } else if (fstate == 3){
9527 BrHXXRatio = (myNPbase->BrHbbRatio());
9528 dBrHXXRatio1 = BrHXXRatio - 1.0;
9529 dBrHXXRatio2 = 0.0;
9530 } else if (fstate == 4){
9531 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9532 dBrHXXRatio1 = BrHXXRatio - 1.0;
9533 dBrHXXRatio2 = 0.0;
9534 } else if (fstate == 5){
9535 BrHXXRatio = (myNPbase->BrHtautauRatio());
9536 dBrHXXRatio1 = BrHXXRatio - 1.0;
9537 dBrHXXRatio2 = 0.0;
9538 } else if (fstate == 6){
9539 BrHXXRatio = (myNPbase->BrHWWRatio());
9540 dBrHXXRatio1 = BrHXXRatio - 1.0;
9541 dBrHXXRatio2 = 0.0;
9542 } else {
9543 throw std::runtime_error("STXS12_qqHqq_mjj1000_1500_pTH0_200_Nj2 called with invalid argument for final state in fstate_i");
9544 }
9545
9546 //-- Production x Decay:
9547 if ((this->getModel()).isModelLinearized()){
9548 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9549 } else if((this->getModel()).isModelNPquadratic()){
9550 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9551 } else {
9552 return weight*(muProd)*(BrHXXRatio);
9553 }
9554
9555
9556}
9557
9558// -----------------------------------------------------------------------------
9559
9560//AG:STXS2024
9561STXS12_qqHqq_mjj1500_Inf_pTH0_200_Nj2::STXS12_qqHqq_mjj1500_Inf_pTH0_200_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
9562: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9563{
9564 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9565 throw std::runtime_error("STXS12_qqHqq_mjj1500_Inf_pTH0_200_Nj2 called with a class whose parent is not NPbase");
9566
9567}
9568
9570{
9571 //-- Production:
9572 double weight = 1.0; //If normalized to the SM
9574 double muProd1 = muProd -1.0;
9575 double muProd2 = 0.0;
9576
9577 //-- Decay:
9578 double BrHXXRatio = 1.0;
9579 double dBrHXXRatio1 = 0.0;
9580 double dBrHXXRatio2 = 0.0;
9581 if (fstate==0){
9582 // Use for Cross-section [pb] with no Higgs-boson decay
9583 weight = 0.21578; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
9584 } else if (fstate == 1){
9585 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9586 dBrHXXRatio1 = BrHXXRatio - 1.0;
9587 dBrHXXRatio2 = 0.0;
9588 } else if (fstate == 2){
9589 BrHXXRatio = (myNPbase->BrHgagaRatio());
9590 dBrHXXRatio1 = BrHXXRatio - 1.0;
9591 dBrHXXRatio2 = 0.0;
9592 } else if (fstate == 3){
9593 BrHXXRatio = (myNPbase->BrHbbRatio());
9594 dBrHXXRatio1 = BrHXXRatio - 1.0;
9595 dBrHXXRatio2 = 0.0;
9596 } else if (fstate == 4){
9597 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9598 dBrHXXRatio1 = BrHXXRatio - 1.0;
9599 dBrHXXRatio2 = 0.0;
9600 } else if (fstate == 5){
9601 BrHXXRatio = (myNPbase->BrHtautauRatio());
9602 dBrHXXRatio1 = BrHXXRatio - 1.0;
9603 dBrHXXRatio2 = 0.0;
9604 } else if (fstate == 6){
9605 BrHXXRatio = (myNPbase->BrHWWRatio());
9606 dBrHXXRatio1 = BrHXXRatio - 1.0;
9607 dBrHXXRatio2 = 0.0;
9608 } else {
9609 throw std::runtime_error("STXS12_qqHqq_mjj1500_Inf_pTH0_200_Nj2 called with invalid argument for final state in fstate_i");
9610 }
9611
9612 //-- Production x Decay:
9613 if ((this->getModel()).isModelLinearized()){
9614 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9615 } else if((this->getModel()).isModelNPquadratic()){
9616 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9617 } else {
9618 return weight*(muProd)*(BrHXXRatio);
9619 }
9620
9621}
9622
9623// -----------------------------------------------------------------------------
9624
9625//AG:STXS2024
9626STXS12_qqHqq_mjj1000_Inf_pTH0_200_Nj2::STXS12_qqHqq_mjj1000_Inf_pTH0_200_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
9627: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9628{
9629 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9630 throw std::runtime_error("STXS12_qqHqq_mjj1000_Inf_pTH0_200_Nj2 called with a class whose parent is not NPbase");
9631
9632}
9633
9635{
9636 //-- Production:
9637 double weight = 1.0; //If normalized to the SM
9638 //Since adding bins, include partial weigths of SM_predictions
9639 //(https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.)
9640 double muProd = (0.22408*(myNPbase->STXS12_qqHqq_mjj1000_1500_pTH0_200_Nj2(sqrt_s))
9641 + 0.21578*(myNPbase->STXS12_qqHqq_mjj1500_Inf_pTH0_200_Nj2(sqrt_s)) / (0.30189+0.21578));
9642 double muProd1 = (0.22408*(myNPbase->STXS12_qqHqq_mjj1000_1500_pTH0_200_Nj2(sqrt_s)-1.0)
9643 + 0.21578*(myNPbase->STXS12_qqHqq_mjj1500_Inf_pTH0_200_Nj2(sqrt_s)-1.0) / (0.30189+0.21578));
9644 double muProd2 = 0.0;
9645
9646 //-- Decay:
9647 double BrHXXRatio = 1.0;
9648 double dBrHXXRatio1 = 0.0;
9649 double dBrHXXRatio2 = 0.0;
9650 if (fstate==0){
9651 // Use for Cross-section [pb] with no Higgs-boson decay
9652 weight = 1.0 ; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
9653 } else if (fstate == 1){
9654 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9655 dBrHXXRatio1 = BrHXXRatio - 1.0;
9656 dBrHXXRatio2 = 0.0;
9657 } else if (fstate == 2){
9658 BrHXXRatio = (myNPbase->BrHgagaRatio());
9659 dBrHXXRatio1 = BrHXXRatio - 1.0;
9660 dBrHXXRatio2 = 0.0;
9661 } else if (fstate == 3){
9662 BrHXXRatio = (myNPbase->BrHbbRatio());
9663 dBrHXXRatio1 = BrHXXRatio - 1.0;
9664 dBrHXXRatio2 = 0.0;
9665 } else if (fstate == 4){
9666 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9667 dBrHXXRatio1 = BrHXXRatio - 1.0;
9668 dBrHXXRatio2 = 0.0;
9669 } else {
9670 throw std::runtime_error("STXS12_qqHqq_mjj1000_Inf_pTH0_200_Nj2 called with invalid argument for final state in fstate_i");
9671 }
9672
9673 //-- Production x Decay:
9674 if ((this->getModel()).isModelLinearized()){
9675 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9676 } else if((this->getModel()).isModelNPquadratic()){
9677 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9678 } else {
9679 return weight*(muProd)*(BrHXXRatio);
9680 }
9681
9682
9683}
9684
9685// -----------------------------------------------------------------------------
9686
9687//AG:STXS2024
9688STXS12_qqHqq_mjj350_1000_pTH200_Inf_Nj2::STXS12_qqHqq_mjj350_1000_pTH200_Inf_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
9689: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9690{
9691 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9692 throw std::runtime_error("STXS12_qqHqq_mjj350_1000_pTH200_Inf_Nj2 called with a class whose parent is not NPbase");
9693
9694}
9695
9697{
9698 //-- Production:
9699 double weight = 1.0; //If normalized to the SM
9701 double muProd1 = muProd -1.0;
9702 double muProd2 = 0.0;
9703
9704 //-- Decay:
9705 double BrHXXRatio = 1.0;
9706 double dBrHXXRatio1 = 0.0;
9707 double dBrHXXRatio2 = 0.0;
9708 if (fstate==0){
9709 // Use for Cross-section [pb] with no Higgs-boson decay
9710 weight = 0.07372 ; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
9711 } else if (fstate == 1){
9712 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9713 dBrHXXRatio1 = BrHXXRatio - 1.0;
9714 dBrHXXRatio2 = 0.0;
9715 } else if (fstate == 2){
9716 BrHXXRatio = (myNPbase->BrHgagaRatio());
9717 dBrHXXRatio1 = BrHXXRatio - 1.0;
9718 dBrHXXRatio2 = 0.0;
9719 } else if (fstate == 3){
9720 BrHXXRatio = (myNPbase->BrHbbRatio());
9721 dBrHXXRatio1 = BrHXXRatio - 1.0;
9722 dBrHXXRatio2 = 0.0;
9723 } else if (fstate == 4){
9724 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9725 dBrHXXRatio1 = BrHXXRatio - 1.0;
9726 dBrHXXRatio2 = 0.0;
9727 } else {
9728 throw std::runtime_error("STXS12_qqHqq_mjj350_1000_pTH200_Inf_Nj2 called with invalid argument for final state in fstate_i");
9729 }
9730
9731 //-- Production x Decay:
9732 if ((this->getModel()).isModelLinearized()){
9733 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9734 } else if((this->getModel()).isModelNPquadratic()){
9735 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9736 } else {
9737 return weight*(muProd)*(BrHXXRatio);
9738 }
9739
9740
9741}
9742
9743// -----------------------------------------------------------------------------
9744
9745//AG:STXS2024
9746STXS12_qqHqq_mjj1000_Inf_pTH200_Inf_Nj2::STXS12_qqHqq_mjj1000_Inf_pTH200_Inf_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
9747: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9748{
9749 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9750 throw std::runtime_error("STXS12_qqHqq_mjj1000_Inf_pTH200_Inf_Nj2 called with a class whose parent is not NPbase");
9751
9752}
9753
9755{
9756 //-- Production:
9757 double weight = 1.0; //If normalized to the SM
9759 double muProd1 = muProd -1.0;
9760 double muProd2 = 0.0;
9761
9762 //-- Decay:
9763 double BrHXXRatio = 1.0;
9764 double dBrHXXRatio1 = 0.0;
9765 double dBrHXXRatio2 = 0.0;
9766 if (fstate==0){
9767 // Use for Cross-section [pb] with no Higgs-boson decay
9768 weight = 0.07315 ; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
9769 } else if (fstate == 1){
9770 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9771 dBrHXXRatio1 = BrHXXRatio - 1.0;
9772 dBrHXXRatio2 = 0.0;
9773 } else if (fstate == 2){
9774 BrHXXRatio = (myNPbase->BrHgagaRatio());
9775 dBrHXXRatio1 = BrHXXRatio - 1.0;
9776 dBrHXXRatio2 = 0.0;
9777 } else if (fstate == 3){
9778 BrHXXRatio = (myNPbase->BrHbbRatio());
9779 dBrHXXRatio1 = BrHXXRatio - 1.0;
9780 dBrHXXRatio2 = 0.0;
9781 } else if (fstate == 4){
9782 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9783 dBrHXXRatio1 = BrHXXRatio - 1.0;
9784 dBrHXXRatio2 = 0.0;
9785 } else {
9786 throw std::runtime_error("STXS12_qqHqq_mjj1000_Inf_pTH200_Inf_Nj2 called with invalid argument for final state in fstate_i");
9787 }
9788
9789 //-- Production x Decay:
9790 if ((this->getModel()).isModelLinearized()){
9791 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9792 } else if((this->getModel()).isModelNPquadratic()){
9793 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9794 } else {
9795 return weight*(muProd)*(BrHXXRatio);
9796 }
9797
9798
9799}
9800
9801// -----------------------------------------------------------------------------
9802
9803STXS12_qqHqq_mjj350_Inf_Nj2::STXS12_qqHqq_mjj350_Inf_Nj2(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
9804: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9805{
9806 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9807 throw std::runtime_error("STXS12_qqHqq_mjj350_Inf_Nj2 called with a class whose parent is not NPbase");
9808
9809}
9810
9812{
9813 //-- Production:
9814 double weight = 1.0; //If normalized to the SM
9815 //Since adding bins, include partial weigths of SM_predictions
9816 //(https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.)
9817
9818 double muProd = (0.53537*myNPbase->STXS12_qqHqq_mjj350_700_pTH0_200_Nj2(sqrt_s)
9824 / (0.53537+0.25614+0.22408+0.21578+0.073727+0.07315) ;
9825
9826 double muProd1 = muProd - 1.;
9827 double muProd2 = 0.0;
9828
9829 //-- Decay:
9830 double BrHXXRatio = 1.0;
9831 double dBrHXXRatio1 = 0.0;
9832 double dBrHXXRatio2 = 0.0;
9833 if (fstate==0){
9834 // Use for Cross-section [pb] with no Higgs-boson decay
9835 weight = (0.53537+0.25614+0.22408+0.21578+0.073727+0.07315); //Ref: https://www.hepdata.net/record/ins2104706 Figure7.
9836 } else if (fstate == 1){
9837 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9838 dBrHXXRatio1 = BrHXXRatio - 1.0;
9839 dBrHXXRatio2 = 0.0;
9840 } else if (fstate == 2){
9841 BrHXXRatio = (myNPbase->BrHgagaRatio());
9842 dBrHXXRatio1 = BrHXXRatio - 1.0;
9843 dBrHXXRatio2 = 0.0;
9844 } else if (fstate == 3){
9845 BrHXXRatio = (myNPbase->BrHbbRatio());
9846 dBrHXXRatio1 = BrHXXRatio - 1.0;
9847 dBrHXXRatio2 = 0.0;
9848 } else if (fstate == 4){
9849 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9850 dBrHXXRatio1 = BrHXXRatio - 1.0;
9851 dBrHXXRatio2 = 0.0;
9852 } else if (fstate == 5){
9853 BrHXXRatio = (myNPbase->BrHtautauRatio());
9854 dBrHXXRatio1 = BrHXXRatio - 1.0;
9855 dBrHXXRatio2 = 0.0;
9856 } else {
9857 throw std::runtime_error("STXS12_qqHqq_mjj350_Inf_Nj2 called with invalid argument for final state in fstate_i");
9858 }
9859
9860
9861
9862
9863 //-- Production x Decay:
9864 if ((this->getModel()).isModelLinearized()){
9865// std::cout<<"\033[1;31m CHECK IF LINEAR \033[0m" << std::endl;
9866 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9867 } else if((this->getModel()).isModelNPquadratic()){
9868// std::cout<<"\033[1;31m CHECK IF QUADRATIC \033[0m" << std::endl;
9869 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9870 } else {
9871// std::cout<<"\033[1;31m CHECK IF NEITHER LINEAR NOR QUADRATIC \033[0m" << std::endl;
9872 return weight*(muProd)*(BrHXXRatio);
9873 }
9874
9875}
9876
9877// -----------------------------------------------------------------------------
9878
9879STXS12_qqHlv_pTV0_75::STXS12_qqHlv_pTV0_75(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
9880: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9881{
9882 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9883 throw std::runtime_error("STXS12_qqHlv_pTV0_75 called with a class whose parent is not NPbase");
9884
9885}
9886
9888{
9889 //-- Production:
9890 double weight = 1.0; //If normalized to the SM
9891 double muProd = myNPbase->STXS12_qqHlv_pTV0_75(sqrt_s);
9892 double muProd1 = muProd -1.0;
9893 double muProd2 = 0.0;
9894
9895 //-- Decay:
9896 double BrHXXRatio = 1.0;
9897 double dBrHXXRatio1 = 0.0;
9898 double dBrHXXRatio2 = 0.0;
9899 if (fstate==0){
9900 // Use for Cross-section [pb] with no Higgs-boson decay
9901 weight = 0.21509; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
9902 } else if (fstate == 1){
9903 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9904 dBrHXXRatio1 = BrHXXRatio - 1.0;
9905 dBrHXXRatio2 = 0.0;
9906 } else if (fstate == 2){
9907 BrHXXRatio = (myNPbase->BrHgagaRatio());
9908 dBrHXXRatio1 = BrHXXRatio - 1.0;
9909 dBrHXXRatio2 = 0.0;
9910 } else if (fstate == 3){
9911 BrHXXRatio = (myNPbase->BrHbbRatio());
9912 dBrHXXRatio1 = BrHXXRatio - 1.0;
9913 dBrHXXRatio2 = 0.0;
9914 } else if (fstate == 4){
9915 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9916 dBrHXXRatio1 = BrHXXRatio - 1.0;
9917 dBrHXXRatio2 = 0.0;
9918 } else if (fstate == 5){
9919 BrHXXRatio = (myNPbase->BrHtautauRatio());
9920 dBrHXXRatio1 = BrHXXRatio - 1.0;
9921 dBrHXXRatio2 = 0.0;
9922 } else {
9923 throw std::runtime_error("STXS12_qqHqq_mjj350_Inf_Nj2 called with invalid argument for final state in fstate_i");
9924 }
9925
9926 //-- Production x Decay:
9927 if ((this->getModel()).isModelLinearized()){
9928 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9929 } else if((this->getModel()).isModelNPquadratic()){
9930 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9931 } else {
9932 return weight*(muProd)*(BrHXXRatio);
9933 }
9934
9935}
9936
9937// -----------------------------------------------------------------------------
9938
9939STXS12_qqHlv_pTV75_150::STXS12_qqHlv_pTV75_150(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
9940: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9941{
9942 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
9943 throw std::runtime_error("STXS12_qqHlv_pTV75_150 called with a class whose parent is not NPbase");
9944
9945}
9946
9948{
9949 //-- Production:
9950 double weight = 1.0; //If normalized to the SM
9951 double muProd = myNPbase->STXS12_qqHlv_pTV75_150(sqrt_s);
9952 double muProd1 = muProd -1.0;
9953 double muProd2 = 0.0;
9954
9955 //-- Decay:
9956 double BrHXXRatio = 1.0;
9957 double dBrHXXRatio1 = 0.0;
9958 double dBrHXXRatio2 = 0.0;
9959 if (fstate==0){
9960 // Use for Cross-section [pb] with no Higgs-boson decay
9961 weight = 0.13440; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
9962 } else if (fstate == 1){
9963 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
9964 dBrHXXRatio1 = BrHXXRatio - 1.0;
9965 dBrHXXRatio2 = 0.0;
9966 } else if (fstate == 2){
9967 BrHXXRatio = (myNPbase->BrHgagaRatio());
9968 dBrHXXRatio1 = BrHXXRatio - 1.0;
9969 dBrHXXRatio2 = 0.0;
9970 } else if (fstate == 3){
9971 BrHXXRatio = (myNPbase->BrHbbRatio());
9972 dBrHXXRatio1 = BrHXXRatio - 1.0;
9973 dBrHXXRatio2 = 0.0;
9974 } else if (fstate == 4){
9975 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
9976 dBrHXXRatio1 = BrHXXRatio - 1.0;
9977 dBrHXXRatio2 = 0.0;
9978 } else if (fstate == 5){
9979 BrHXXRatio = (myNPbase->BrHtautauRatio());
9980 dBrHXXRatio1 = BrHXXRatio - 1.0;
9981 dBrHXXRatio2 = 0.0;
9982 } else {
9983 throw std::runtime_error("STXS12_qqHlv_pTV75_150 called with invalid argument for final state in fstate_i");
9984 }
9985
9986 //-- Production x Decay:
9987 if ((this->getModel()).isModelLinearized()){
9988 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9989 } else if((this->getModel()).isModelNPquadratic()){
9990 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9991 } else {
9992 return weight*(muProd)*(BrHXXRatio);
9993 }
9994
9995}
9996
9997// -----------------------------------------------------------------------------
9998
9999//AG:STXS2024
10000STXS12_qqHlv_pTV150_250_Nj0::STXS12_qqHlv_pTV150_250_Nj0(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
10001: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10002{
10003 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10004 throw std::runtime_error("STXS12_qqHlv_pTV150_250_Nj0 called with a class whose parent is not NPbase");
10005
10006}
10007
10009{
10010 //-- Production:
10011 double weight = 1.0; //If normalized to the SM
10013 double muProd1 = myNPbase->STXS12_qqHlv_pTV150_250_Nj0(sqrt_s) - 1.0;
10014 double muProd2 = 0.0;
10015
10016 //-- Decay:
10017 double BrHXXRatio = 1.0;
10018 double dBrHXXRatio1 = 0.0;
10019 double dBrHXXRatio2 = 0.0;
10020 if (fstate==0){
10021 // Use for Cross-section [pb] with no Higgs-boson decay
10022 weight = 0.04117; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
10023 } else if (fstate == 1){
10024 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10025 dBrHXXRatio1 = BrHXXRatio - 1.0;
10026 dBrHXXRatio2 = 0.0;
10027 } else if (fstate == 2){
10028 BrHXXRatio = (myNPbase->BrHgagaRatio());
10029 dBrHXXRatio1 = BrHXXRatio - 1.0;
10030 dBrHXXRatio2 = 0.0;
10031 } else if (fstate == 3){
10032 BrHXXRatio = (myNPbase->BrHbbRatio());
10033 dBrHXXRatio1 = BrHXXRatio - 1.0;
10034 dBrHXXRatio2 = 0.0;
10035 } else if (fstate == 4){
10036 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10037 dBrHXXRatio1 = BrHXXRatio - 1.0;
10038 dBrHXXRatio2 = 0.0;
10039 } else if (fstate == 5){
10040 BrHXXRatio = (myNPbase->BrHtautauRatio());
10041 dBrHXXRatio1 = BrHXXRatio - 1.0;
10042 dBrHXXRatio2 = 0.0;
10043 } else {
10044 throw std::runtime_error("STXS12_qqHqq_mjj350_Inf_Nj2 called with invalid argument for final state in fstate_i");
10045 }
10046
10047 //-- Production x Decay:
10048 if ((this->getModel()).isModelLinearized()){
10049 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10050 } else if((this->getModel()).isModelNPquadratic()){
10051 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10052 } else {
10053 return weight*(muProd)*(BrHXXRatio);
10054 }
10055
10056
10057}
10058
10059// -----------------------------------------------------------------------------
10060
10061STXS12_qqHlv_pTV150_250_Nj1::STXS12_qqHlv_pTV150_250_Nj1(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
10062: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10063{
10064 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10065 throw std::runtime_error("STXS12_qqHlv_pTV150_250_Nj1 called with a class whose parent is not NPbase");
10066
10067}
10068
10070{
10071 double BrHXXRatio = 1.0;
10072 if (fstate == 1){
10073 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10074 } else if (fstate == 2){
10075 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
10076 } else if (fstate == 3){
10077 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
10078 } else if (fstate == 4){
10079 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10080 } else {
10081 throw std::runtime_error("STXS12_qqHlv_pTV150_250_Nj1 called with invalid argument for final state in fstate_i");
10082 }
10083
10084 if ((this->getModel()).isModelLinearized()) {
10085 return ((myNPbase->STXS12_qqHlv_pTV150_250_Nj1(sqrt_s)) + (BrHXXRatio) - 1.0);
10086 } else {
10087 return (myNPbase->STXS12_qqHlv_pTV150_250_Nj1(sqrt_s))*(BrHXXRatio);
10088 }
10089}
10090
10091// -----------------------------------------------------------------------------
10092
10093STXS12_qqHlv_pTV250_Inf::STXS12_qqHlv_pTV250_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
10094: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10095{
10096 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10097 throw std::runtime_error("STXS12_qqHlv_pTV250_Inf called with a class whose parent is not NPbase");
10098
10099}
10100
10102{
10103 double BrHXXRatio = 1.0;
10104 if (fstate == 1){
10105 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10106 } else if (fstate == 2){
10107 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
10108 } else if (fstate == 3){
10109 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
10110 } else if (fstate == 4){
10111 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10112 } else {
10113 throw std::runtime_error("STXS12_qqHlv_pTV250_Inf called with invalid argument for final state in fstate_i");
10114 }
10115
10116 if ((this->getModel()).isModelLinearized()) {
10117 return ((myNPbase->STXS12_qqHlv_pTV250_Inf(sqrt_s)) + (BrHXXRatio) - 1.0);
10118 } else {
10119 return (myNPbase->STXS12_qqHlv_pTV250_Inf(sqrt_s))*(BrHXXRatio);
10120 }
10121}
10122
10123// -----------------------------------------------------------------------------
10124
10125//AG:STXS2024
10126STXS12_qqHlv_pTV0_150::STXS12_qqHlv_pTV0_150(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
10127: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10128{
10129 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10130 throw std::runtime_error("STXS12_qqHlv_pTV0_150 called with a class whose parent is not NPbase");
10131
10132}
10133
10135{
10136 //-- Production:
10137 double weight = 1.0; //If normalized to the SM
10138 //Since adding bins, include partial weigths of SM_predictions
10139 //(https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.)
10140 double muProd = (0.21509*(myNPbase->STXS12_qqHlv_pTV0_75(sqrt_s))
10141 + 0.13440*(myNPbase->STXS12_qqHlv_pTV75_150(sqrt_s))/(0.21509+0.13440));
10142 double muProd1 = (0.21509*(myNPbase->STXS12_qqHlv_pTV0_75(sqrt_s)-1.0)
10143 + 0.13440*(myNPbase->STXS12_qqHlv_pTV75_150(sqrt_s)-1.0)/(0.21509+0.13440));
10144 double muProd2 = 0.0;
10145
10146 //-- Decay:
10147 double BrHXXRatio = 1.0;
10148 double dBrHXXRatio1 = 0.0;
10149 double dBrHXXRatio2 = 0.0;
10150 if (fstate==0){
10151 // Use for Cross-section [pb] with no Higgs-boson decay
10152 weight = 1.0 ; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
10153 } else if (fstate == 1){
10154 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10155 dBrHXXRatio1 = BrHXXRatio - 1.0;
10156 dBrHXXRatio2 = 0.0;
10157 } else if (fstate == 2){
10158 BrHXXRatio = (myNPbase->BrHgagaRatio());
10159 dBrHXXRatio1 = BrHXXRatio - 1.0;
10160 dBrHXXRatio2 = 0.0;
10161 } else if (fstate == 3){
10162 BrHXXRatio = (myNPbase->BrHbbRatio());
10163 dBrHXXRatio1 = BrHXXRatio - 1.0;
10164 dBrHXXRatio2 = 0.0;
10165 } else if (fstate == 4){
10166 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10167 dBrHXXRatio1 = BrHXXRatio - 1.0;
10168 dBrHXXRatio2 = 0.0;
10169 } else {
10170 throw std::runtime_error("STXS12_qqHlv_pTV0_150 called with invalid argument for final state in fstate_i");
10171 }
10172
10173 //-- Production x Decay:
10174 if ((this->getModel()).isModelLinearized()){
10175 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10176 } else if((this->getModel()).isModelNPquadratic()){
10177 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10178 } else {
10179 return weight*(muProd)*(BrHXXRatio);
10180 }
10181
10182
10183}
10184
10185// -----------------------------------------------------------------------------
10186
10187//AG:STXS2024
10188STXS12_qqHlv_pTV150_Inf::STXS12_qqHlv_pTV150_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
10189: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10190{
10191 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10192 throw std::runtime_error("STXS12_qqHlv_pTV150_Inf called with a class whose parent is not NPbase");
10193
10194}
10195
10197{
10198 //-- Production:
10199 double weight = 1.0; //If normalized to the SM
10200 //Since adding bins, include partial weigths of SM_predictions
10201 //(https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.)
10202 double muProd = (0.04117 * myNPbase->STXS12_qqHlv_pTV150_250_Nj0(sqrt_s)
10204 + 0.00214 * myNPbase->STXS12_qqHlv_pTV400_Inf(sqrt_s) )/(0.04117+0.01004+0.00214);
10205 double muProd1 = (0.04117 * (myNPbase->STXS12_qqHlv_pTV150_250_Nj0(sqrt_s) -1.0)
10206 + 0.01004 * (myNPbase->STXS12_qqHlv_pTV250_400(sqrt_s)-1.0)
10207 + 0.00214 * (myNPbase->STXS12_qqHlv_pTV400_Inf(sqrt_s)-1.0) )/(0.04117+0.01004+0.00214);
10208 double muProd2 = 0.0;
10209
10210 //-- Decay:
10211 double BrHXXRatio = 1.0;
10212 double dBrHXXRatio1 = 0.0;
10213 double dBrHXXRatio2 = 0.0;
10214 if (fstate==0){
10215 // Use for Cross-section [pb] with no Higgs-boson decay
10216 weight = 1.0 ;
10217 } else if (fstate == 1){
10218 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10219 dBrHXXRatio1 = BrHXXRatio - 1.0;
10220 dBrHXXRatio2 = 0.0;
10221 } else if (fstate == 2){
10222 BrHXXRatio = (myNPbase->BrHgagaRatio());
10223 dBrHXXRatio1 = BrHXXRatio - 1.0;
10224 dBrHXXRatio2 = 0.0;
10225 } else if (fstate == 3){
10226 BrHXXRatio = (myNPbase->BrHbbRatio());
10227 dBrHXXRatio1 = BrHXXRatio - 1.0;
10228 dBrHXXRatio2 = 0.0;
10229 } else if (fstate == 4){
10230 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10231 dBrHXXRatio1 = BrHXXRatio - 1.0;
10232 dBrHXXRatio2 = 0.0;
10233 } else {
10234 throw std::runtime_error("STXS12_qqHlv_pTV150_Inf called with invalid argument for final state in fstate_i");
10235 }
10236
10237 //-- Production x Decay:
10238 if ((this->getModel()).isModelLinearized()){
10239 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10240 } else if((this->getModel()).isModelNPquadratic()){
10241 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10242 } else {
10243 return weight*(muProd)*(BrHXXRatio);
10244 }
10245
10246
10247}
10248
10249// -----------------------------------------------------------------------------
10250
10251//AG:STXS2024
10252STXS12_qqHlv_pTV250_400::STXS12_qqHlv_pTV250_400(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
10253: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10254{
10255 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10256 throw std::runtime_error("STXS12_qqHlv_pTV250_400 called with a class whose parent is not NPbase");
10257
10258}
10259
10261{
10262 //-- Production:
10263 double weight = 1.0; //If normalized to the SM
10264 double muProd = myNPbase->STXS12_qqHlv_pTV250_400(sqrt_s) ;
10265 double muProd1 = myNPbase->STXS12_qqHlv_pTV250_400(sqrt_s)-1.0 ;
10266 double muProd2 = 0.0;
10267
10268 //-- Decay:
10269 double BrHXXRatio = 1.0;
10270 double dBrHXXRatio1 = 0.0;
10271 double dBrHXXRatio2 = 0.0;
10272 if (fstate==0){
10273 // Use for Cross-section [pb] with no Higgs-boson decay
10274 weight =0.01004 ; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
10275 } else if (fstate == 1){
10276 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10277 dBrHXXRatio1 = BrHXXRatio - 1.0;
10278 dBrHXXRatio2 = 0.0;
10279 } else if (fstate == 2){
10280 BrHXXRatio = (myNPbase->BrHgagaRatio());
10281 dBrHXXRatio1 = BrHXXRatio - 1.0;
10282 dBrHXXRatio2 = 0.0;
10283 } else if (fstate == 3){
10284 BrHXXRatio = (myNPbase->BrHbbRatio());
10285 dBrHXXRatio1 = BrHXXRatio - 1.0;
10286 dBrHXXRatio2 = 0.0;
10287 } else if (fstate == 4){
10288 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10289 dBrHXXRatio1 = BrHXXRatio - 1.0;
10290 dBrHXXRatio2 = 0.0;
10291 } else {
10292 throw std::runtime_error("STXS12_qqHlv_pTV250_400 called with invalid argument for final state in fstate_i");
10293 }
10294
10295 //-- Production x Decay:
10296 if ((this->getModel()).isModelLinearized()){
10297 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10298 } else if((this->getModel()).isModelNPquadratic()){
10299 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10300 } else {
10301 return weight*(muProd)*(BrHXXRatio);
10302 }
10303
10304
10305}
10306
10307// -----------------------------------------------------------------------------
10308
10309//AG:STXS2024
10310STXS12_qqHlv_pTV400_Inf::STXS12_qqHlv_pTV400_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
10311: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10312{
10313 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10314 throw std::runtime_error("STXS12_qqHlv_pTV400_Inf called with a class whose parent is not NPbase");
10315
10316}
10317
10319{
10320 //-- Production:
10321 double weight = 1.0; //If normalized to the SM
10322 double muProd = myNPbase->STXS12_qqHlv_pTV400_Inf(sqrt_s) ;
10323 double muProd1 = muProd-1.0 ;
10324 double muProd2 = 0.0;
10325
10326 //-- Decay:
10327 double BrHXXRatio = 1.0;
10328 double dBrHXXRatio1 = 0.0;
10329 double dBrHXXRatio2 = 0.0;
10330 if (fstate==0){
10331 // Use for Cross-section [pb] with no Higgs-boson decay
10332 weight =0.00214 ; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
10333 } else if (fstate == 1){
10334 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10335 dBrHXXRatio1 = BrHXXRatio - 1.0;
10336 dBrHXXRatio2 = 0.0;
10337 } else if (fstate == 2){
10338 BrHXXRatio = (myNPbase->BrHgagaRatio());
10339 dBrHXXRatio1 = BrHXXRatio - 1.0;
10340 dBrHXXRatio2 = 0.0;
10341 } else if (fstate == 3){
10342 BrHXXRatio = (myNPbase->BrHbbRatio());
10343 dBrHXXRatio1 = BrHXXRatio - 1.0;
10344 dBrHXXRatio2 = 0.0;
10345 } else if (fstate == 4){
10346 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10347 dBrHXXRatio1 = BrHXXRatio - 1.0;
10348 dBrHXXRatio2 = 0.0;
10349 } else {
10350 throw std::runtime_error("STXS12_qqHlv_pTV400_Inf called with invalid argument for final state in fstate_i");
10351 }
10352
10353 //-- Production x Decay:
10354 if ((this->getModel()).isModelLinearized()){
10355 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10356 } else if((this->getModel()).isModelNPquadratic()){
10357 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10358 } else {
10359 return weight*(muProd)*(BrHXXRatio);
10360 }
10361
10362
10363}
10364
10365
10366// -----------------------------------------------------------------------------
10367
10368STXS12_qqHll_pTV0_75::STXS12_qqHll_pTV0_75(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
10369: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10370{
10371 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10372 throw std::runtime_error("STXS12_qqHll_pTV0_75 called with a class whose parent is not NPbase");
10373
10374}
10375
10377{
10378 double BrHXXRatio = 1.0;
10379 if (fstate == 1){
10380 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10381 } else if (fstate == 2){
10382 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
10383 } else if (fstate == 3){
10384 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
10385 } else if (fstate == 4){
10386 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10387 } else {
10388 throw std::runtime_error("STXS12_qqHll_pTV0_75 called with invalid argument for final state in fstate_i");
10389 }
10390
10391 if ((this->getModel()).isModelLinearized()) {
10392 return ((myNPbase->STXS12_qqHll_pTV0_75(sqrt_s)) + (BrHXXRatio) - 1.0);
10393 } else {
10394 return (myNPbase->STXS12_qqHll_pTV0_75(sqrt_s))*(BrHXXRatio);
10395 }
10396}
10397
10398// -----------------------------------------------------------------------------
10399
10400//AG:STXS2024
10401STXS12_qqHll_pTV75_150::STXS12_qqHll_pTV75_150(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
10402: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10403{
10404 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10405 throw std::runtime_error("STXS12_qqHll_pTV75_150 called with a class whose parent is not NPbase");
10406
10407}
10408
10410{
10411 //-- Production:
10412 double weight = 1.0; //If normalized to the SM
10413 double muProd = myNPbase->STXS12_qqHll_pTV75_150(sqrt_s);
10414 double muProd1 = muProd -1.0;
10415 double muProd2 = 0.0;
10416
10417 //-- Decay:
10418 double BrHXXRatio = 1.0;
10419 double dBrHXXRatio1 = 0.0;
10420 double dBrHXXRatio2 = 0.0;
10421 if (fstate==0){
10422 // Use for Cross-section [pb] with no Higgs-boson decay
10423 weight = 1.0 ; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
10424 } else if (fstate == 1){
10425 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10426 dBrHXXRatio1 = BrHXXRatio - 1.0;
10427 dBrHXXRatio2 = 0.0;
10428 } else if (fstate == 2){
10429 BrHXXRatio = (myNPbase->BrHgagaRatio());
10430 dBrHXXRatio1 = BrHXXRatio - 1.0;
10431 dBrHXXRatio2 = 0.0;
10432 } else if (fstate == 3){
10433 BrHXXRatio = (myNPbase->BrHbbRatio());
10434 dBrHXXRatio1 = BrHXXRatio - 1.0;
10435 dBrHXXRatio2 = 0.0;
10436 } else if (fstate == 4){
10437 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10438 dBrHXXRatio1 = BrHXXRatio - 1.0;
10439 dBrHXXRatio2 = 0.0;
10440 } else {
10441 throw std::runtime_error("STXS12_qqHll_pTV75_150 called with invalid argument for final state in fstate_i");
10442 }
10443
10444 //-- Production x Decay:
10445 if ((this->getModel()).isModelLinearized()){
10446 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10447 } else if((this->getModel()).isModelNPquadratic()){
10448 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10449 } else {
10450 return weight*(muProd)*(BrHXXRatio);
10451 }
10452
10453
10454}
10455
10456// -----------------------------------------------------------------------------
10457
10458//AG:STXS2024
10459STXS12_qqHll_pTV150_250_Nj0::STXS12_qqHll_pTV150_250_Nj0(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
10460: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10461{
10462 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10463 throw std::runtime_error("STXS12_qqHll_pTV150_250_Nj0 called with a class whose parent is not NPbase");
10464
10465}
10466
10468{
10469 //-- Production:
10470 double weight = 1.0; //If normalized to the SM
10472 double muProd1 = muProd -1.0;
10473 double muProd2 = 0.0;
10474
10475 //-- Decay:
10476 double BrHXXRatio = 1.0;
10477 double dBrHXXRatio1 = 0.0;
10478 double dBrHXXRatio2 = 0.0;
10479 if (fstate==0){
10480 // Use for Cross-section [pb] with no Higgs-boson decay
10481 weight = 0.03223 ; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
10482 } else if (fstate == 1){
10483 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10484 dBrHXXRatio1 = BrHXXRatio - 1.0;
10485 dBrHXXRatio2 = 0.0;
10486 } else if (fstate == 2){
10487 BrHXXRatio = (myNPbase->BrHgagaRatio());
10488 dBrHXXRatio1 = BrHXXRatio - 1.0;
10489 dBrHXXRatio2 = 0.0;
10490 } else if (fstate == 3){
10491 BrHXXRatio = (myNPbase->BrHbbRatio());
10492 dBrHXXRatio1 = BrHXXRatio - 1.0;
10493 dBrHXXRatio2 = 0.0;
10494 } else if (fstate == 4){
10495 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10496 dBrHXXRatio1 = BrHXXRatio - 1.0;
10497 dBrHXXRatio2 = 0.0;
10498 } else {
10499 throw std::runtime_error("STXS12_qqHll_pTV150_250_Nj0 called with invalid argument for final state in fstate_i");
10500 }
10501
10502 //-- Production x Decay:
10503 if ((this->getModel()).isModelLinearized()){
10504 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10505 } else if((this->getModel()).isModelNPquadratic()){
10506 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10507 } else {
10508 return weight*(muProd)*(BrHXXRatio);
10509 }
10510
10511}
10512
10513// -----------------------------------------------------------------------------
10514
10515STXS12_qqHll_pTV150_250_Nj1::STXS12_qqHll_pTV150_250_Nj1(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
10516: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10517{
10518 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10519 throw std::runtime_error("STXS12_qqHll_pTV150_250_Nj1 called with a class whose parent is not NPbase");
10520
10521}
10522
10524{
10525 double BrHXXRatio = 1.0;
10526 if (fstate == 1){
10527 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10528 } else if (fstate == 2){
10529 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
10530 } else if (fstate == 3){
10531 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
10532 } else if (fstate == 4){
10533 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10534 } else {
10535 throw std::runtime_error("STXS12_qqHll_pTV150_250_Nj1 called with invalid argument for final state in fstate_i");
10536 }
10537
10538 if ((this->getModel()).isModelLinearized()) {
10539 return ((myNPbase->STXS12_qqHll_pTV150_250_Nj1(sqrt_s)) + (BrHXXRatio) - 1.0);
10540 } else {
10541 return (myNPbase->STXS12_qqHll_pTV150_250_Nj1(sqrt_s))*(BrHXXRatio);
10542 }
10543}
10544
10545// -----------------------------------------------------------------------------
10546
10547STXS12_qqHll_pTV250_Inf::STXS12_qqHll_pTV250_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
10548: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10549{
10550 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10551 throw std::runtime_error("STXS12_qqHll_pTV250_Inf called with a class whose parent is not NPbase");
10552
10553}
10554
10556{
10557 double BrHXXRatio = 1.0;
10558 if (fstate == 1){
10559 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10560 } else if (fstate == 2){
10561 BrHXXRatio = (myNPbase->STXS12_BrHgagaRatio());
10562 } else if (fstate == 3){
10563 BrHXXRatio = (myNPbase->STXS12_BrHbbRatio());
10564 } else if (fstate == 4){
10565 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10566 } else {
10567 throw std::runtime_error("STXS12_qqHll_pTV250_Inf called with invalid argument for final state in fstate_i");
10568 }
10569
10570 if ((this->getModel()).isModelLinearized()) {
10571 return ((myNPbase->STXS12_qqHll_pTV250_Inf(sqrt_s)) + (BrHXXRatio) - 1.0);
10572 } else {
10573 return (myNPbase->STXS12_qqHll_pTV250_Inf(sqrt_s))*(BrHXXRatio);
10574 }
10575}
10576
10577
10578// -----------------------------------------------------------------------------
10579
10580//AG:STXS2024
10581STXS12_qqHll_pTV0_150::STXS12_qqHll_pTV0_150(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
10582: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10583{
10584 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10585 throw std::runtime_error("STXS12_qqHll_pTV0_150 called with a class whose parent is not NPbase");
10586
10587}
10588
10590{
10591 //-- Production:
10592 double weight = 1.0; //If normalized to the SM
10593 double muProd = myNPbase->STXS12_qqHll_pTV0_150(sqrt_s);
10594 double muProd1 = muProd -1.0;
10595 double muProd2 = 0.0;
10596
10597 //-- Decay:
10598 double BrHXXRatio = 1.0;
10599 double dBrHXXRatio1 = 0.0;
10600 double dBrHXXRatio2 = 0.0;
10601 if (fstate==0){
10602 // Use for Cross-section [pb] with no Higgs-boson decay
10603 weight = 0.19845 ; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
10604 } else if (fstate == 1){
10605 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10606 dBrHXXRatio1 = BrHXXRatio - 1.0;
10607 dBrHXXRatio2 = 0.0;
10608 } else if (fstate == 2){
10609 BrHXXRatio = (myNPbase->BrHgagaRatio());
10610 dBrHXXRatio1 = BrHXXRatio - 1.0;
10611 dBrHXXRatio2 = 0.0;
10612 } else if (fstate == 3){
10613 BrHXXRatio = (myNPbase->BrHbbRatio());
10614 dBrHXXRatio1 = BrHXXRatio - 1.0;
10615 dBrHXXRatio2 = 0.0;
10616 } else if (fstate == 4){
10617 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10618 dBrHXXRatio1 = BrHXXRatio - 1.0;
10619 dBrHXXRatio2 = 0.0;
10620 } else {
10621 throw std::runtime_error("STXS12_qqHll_pTV0_150 called with invalid argument for final state in fstate_i");
10622 }
10623
10624 //-- Production x Decay:
10625 if ((this->getModel()).isModelLinearized()){
10626 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10627 } else if((this->getModel()).isModelNPquadratic()){
10628 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10629 } else {
10630 return weight*(muProd)*(BrHXXRatio);
10631 }
10632
10633}
10634
10635// -----------------------------------------------------------------------------
10636
10637//AG:STXS2024
10638STXS12_qqHll_pTV250_400::STXS12_qqHll_pTV250_400(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
10639: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10640{
10641 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10642 throw std::runtime_error("STXS12_qqHll_pTV250_400 called with a class whose parent is not NPbase");
10643
10644}
10645
10647{
10648 //-- Production:
10649 double weight = 1.0; //If normalized to the SM
10650 double muProd = myNPbase->STXS12_qqHll_pTV250_400(sqrt_s);
10651 double muProd1 = muProd -1.0;
10652 double muProd2 = 0.0;
10653
10654 //-- Decay:
10655 double BrHXXRatio = 1.0;
10656 double dBrHXXRatio1 = 0.0;
10657 double dBrHXXRatio2 = 0.0;
10658 if (fstate==0){
10659 // Use for Cross-section [pb] with no Higgs-boson decay
10660 weight = 0.00715 ; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
10661 } else if (fstate == 1){
10662 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10663 dBrHXXRatio1 = BrHXXRatio - 1.0;
10664 dBrHXXRatio2 = 0.0;
10665 } else if (fstate == 2){
10666 BrHXXRatio = (myNPbase->BrHgagaRatio());
10667 dBrHXXRatio1 = BrHXXRatio - 1.0;
10668 dBrHXXRatio2 = 0.0;
10669 } else if (fstate == 3){
10670 BrHXXRatio = (myNPbase->BrHbbRatio());
10671 dBrHXXRatio1 = BrHXXRatio - 1.0;
10672 dBrHXXRatio2 = 0.0;
10673 } else if (fstate == 4){
10674 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10675 dBrHXXRatio1 = BrHXXRatio - 1.0;
10676 dBrHXXRatio2 = 0.0;
10677 } else {
10678 throw std::runtime_error("STXS12_qqHll_pTV250_400 called with invalid argument for final state in fstate_i");
10679 }
10680
10681 //-- Production x Decay:
10682 if ((this->getModel()).isModelLinearized()){
10683 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10684 } else if((this->getModel()).isModelNPquadratic()){
10685 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10686 } else {
10687 return weight*(muProd)*(BrHXXRatio);
10688 }
10689
10690}
10691
10692// -----------------------------------------------------------------------------
10693
10694//AG:STXS2024
10695STXS12_qqHll_pTV400_Inf::STXS12_qqHll_pTV400_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
10696: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10697{
10698 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10699 throw std::runtime_error("STXS12_qqHll_pTV400_Inf called with a class whose parent is not NPbase");
10700
10701}
10702
10704{
10705 //-- Production:
10706 double weight = 1.0; //If normalized to the SM
10707 double muProd = myNPbase->STXS12_qqHll_pTV400_Inf(sqrt_s);
10708 double muProd1 = muProd -1.0;
10709 double muProd2 = 0.0;
10710
10711 //-- Decay:
10712 double BrHXXRatio = 1.0;
10713 double dBrHXXRatio1 = 0.0;
10714 double dBrHXXRatio2 = 0.0;
10715 if (fstate==0){
10716 // Use for Cross-section [pb] with no Higgs-boson decay
10717 weight = 0.00126 ; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
10718 } else if (fstate == 1){
10719 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10720 dBrHXXRatio1 = BrHXXRatio - 1.0;
10721 dBrHXXRatio2 = 0.0;
10722 } else if (fstate == 2){
10723 BrHXXRatio = (myNPbase->BrHgagaRatio());
10724 dBrHXXRatio1 = BrHXXRatio - 1.0;
10725 dBrHXXRatio2 = 0.0;
10726 } else if (fstate == 3){
10727 BrHXXRatio = (myNPbase->BrHbbRatio());
10728 dBrHXXRatio1 = BrHXXRatio - 1.0;
10729 dBrHXXRatio2 = 0.0;
10730 } else if (fstate == 4){
10731 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10732 dBrHXXRatio1 = BrHXXRatio - 1.0;
10733 dBrHXXRatio2 = 0.0;
10734 } else {
10735 throw std::runtime_error("STXS12_qqHll_pTV400_Inf called with invalid argument for final state in fstate_i");
10736 }
10737
10738 //-- Production x Decay:
10739 if ((this->getModel()).isModelLinearized()){
10740 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10741 } else if((this->getModel()).isModelNPquadratic()){
10742 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10743 } else {
10744 return weight*(muProd)*(BrHXXRatio);
10745 }
10746
10747
10748}
10749
10750// -----------------------------------------------------------------------------
10751
10752//AG:STXS2024
10753STXS12_qqHll_pTV150_Inf::STXS12_qqHll_pTV150_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
10754: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10755{
10756 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10757 throw std::runtime_error("STXS12_qqHll_pTV150_Inf called with a class whose parent is not NPbase");
10758
10759}
10760
10762{
10763 //-- Production:
10764 double weight = 1.0; //If normalized to the SM
10765 //Since adding bins, include partial weigths of SM_predictions
10766 //(https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.)
10767 double muProd = (0.03223*(myNPbase->STXS12_qqHll_pTV150_250_Nj0(sqrt_s))
10769 + 0.00126*(myNPbase->STXS12_qqHll_pTV400_Inf(sqrt_s)) )/(0.03223+0.00715+0.00126);
10770 double muProd1 = (0.03223*(myNPbase->STXS12_qqHll_pTV150_250_Nj0(sqrt_s)-1.0)
10771 + 0.00715*(myNPbase->STXS12_qqHll_pTV250_400(sqrt_s)-1.0)
10772 + 0.00126*(myNPbase->STXS12_qqHll_pTV400_Inf(sqrt_s)-1.0) )/(0.03223+0.00715+0.00126);
10773 double muProd2 = 0.0;
10774
10775 //-- Decay:
10776 double BrHXXRatio = 1.0;
10777 double dBrHXXRatio1 = 0.0;
10778 double dBrHXXRatio2 = 0.0;
10779 if (fstate==0){
10780 weight = 1.0 ;
10781 } else if (fstate == 1){
10782 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10783 dBrHXXRatio1 = BrHXXRatio - 1.0;
10784 dBrHXXRatio2 = 0.0;
10785 } else if (fstate == 2){
10786 BrHXXRatio = (myNPbase->BrHgagaRatio());
10787 dBrHXXRatio1 = BrHXXRatio - 1.0;
10788 dBrHXXRatio2 = 0.0;
10789 } else if (fstate == 3){
10790 BrHXXRatio = (myNPbase->BrHbbRatio());
10791 dBrHXXRatio1 = BrHXXRatio - 1.0;
10792 dBrHXXRatio2 = 0.0;
10793 } else if (fstate == 4){
10794 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10795 dBrHXXRatio1 = BrHXXRatio - 1.0;
10796 dBrHXXRatio2 = 0.0;
10797 } else {
10798 throw std::runtime_error("STXS12_qqHll_pTV150_Inf called with invalid argument for final state in fstate_i");
10799 }
10800
10801 //-- Production x Decay:
10802 if ((this->getModel()).isModelLinearized()){
10803 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10804 } else if((this->getModel()).isModelNPquadratic()){
10805 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10806 } else {
10807 return weight*(muProd)*(BrHXXRatio);
10808 }
10809
10810
10811}
10812
10813// -----------------------------------------------------------------------------
10814
10815//AG:STXS2024
10816STXS12_VHlep::STXS12_VHlep(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
10817: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10818{
10819 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10820 throw std::runtime_error("STXS12_VHlep called with a class whose parent is not NPbase");
10821
10822}
10823
10825{
10826 //-- Production:
10827 double weight = 1.0; //If normalized to the SM
10828 //Since adding bins, include partial weigths of SM_predictions
10829 //(https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.)
10830 double muProd = ( 0.71256*myNPbase->STXS12_qqHlv_pTV0_75(sqrt_s)
10839 /(0.71256 + 0.06739 + 0.03943 + 0.01127 + 0.00339 + 0.07934 + 0.03525 + 0.00746 + 0.00043);
10840 double muProd1 = ( 0.71256*(myNPbase->STXS12_qqHlv_pTV0_75(sqrt_s)-1.0)
10841 + 0.06739*(myNPbase->STXS12_qqHlv_pTV75_150(sqrt_s)-1.0)
10843 + 0.01127*(myNPbase->STXS12_qqHlv_pTV250_400(sqrt_s)-1.0)
10844 + 0.00339*(myNPbase->STXS12_qqHlv_pTV400_Inf(sqrt_s)-1.0)
10845 + 0.07934*(myNPbase->STXS12_qqHll_pTV0_150(sqrt_s) -1.0)
10847 + 0.00746*(myNPbase->STXS12_qqHll_pTV250_400(sqrt_s)-1.0)
10848 + 0.00043*(myNPbase->STXS12_qqHll_pTV400_Inf(sqrt_s)-1.0) )
10849 /(0.71256 + 0.06739 + 0.03943 + 0.01127 + 0.00339 + 0.07934 + 0.03525 + 0.00746 + 0.00043);
10850 double muProd2 = 0.0;
10851
10852 //-- Decay:
10853 double BrHXXRatio = 1.0;
10854 double dBrHXXRatio1 = 0.0;
10855 double dBrHXXRatio2 = 0.0;
10856 if (fstate==0){
10857 weight = 1.0;
10858 } else if (fstate == 1){
10859 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10860 dBrHXXRatio1 = BrHXXRatio - 1.0;
10861 dBrHXXRatio2 = 0.0;
10862 } else if (fstate == 2){
10863 BrHXXRatio = (myNPbase->BrHgagaRatio());
10864 dBrHXXRatio1 = BrHXXRatio - 1.0;
10865 dBrHXXRatio2 = 0.0;
10866 } else if (fstate == 3){
10867 BrHXXRatio = (myNPbase->BrHbbRatio());
10868 dBrHXXRatio1 = BrHXXRatio - 1.0;
10869 dBrHXXRatio2 = 0.0;
10870 } else if (fstate == 4){
10871 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10872 dBrHXXRatio1 = BrHXXRatio - 1.0;
10873 dBrHXXRatio2 = 0.0;
10874 } else if (fstate == 5){
10875 BrHXXRatio = (myNPbase->BrHtautauRatio());
10876 dBrHXXRatio1 = BrHXXRatio - 1.0;
10877 dBrHXXRatio2 = 0.0;
10878 } else if (fstate == 6){
10879 BrHXXRatio = (myNPbase->BrHWWRatio());
10880 dBrHXXRatio1 = BrHXXRatio - 1.0;
10881 dBrHXXRatio2 = 0.0;
10882 } else if (fstate == 7){
10883 BrHXXRatio = (myNPbase->BrHZZRatio());
10884 dBrHXXRatio1 = BrHXXRatio - 1.0;
10885 dBrHXXRatio2 = 0.0;
10886 } else {
10887 throw std::runtime_error("STXS12_VHlep called with invalid argument for final state in fstate_i");
10888 }
10889
10890 //-- Production x Decay:
10891 if ((this->getModel()).isModelLinearized()){
10892 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10893 } else if((this->getModel()).isModelNPquadratic()){
10894 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10895 } else {
10896 return weight*(muProd)*(BrHXXRatio);
10897 }
10898
10899
10900}
10901
10902// -----------------------------------------------------------------------------
10903
10904//AG:STXS2024
10905STXS12_ttH_pTH0_60::STXS12_ttH_pTH0_60(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
10906: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10907{
10908 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10909 throw std::runtime_error("STXS12_ttH_pTH0_60 called with a class whose parent is not NPbase");
10910
10911}
10912
10914{
10915 //-- Production:
10916 double weight = 1.0; //If normalized to the SM
10917 double muProd = myNPbase->STXS12_ttH_pTH0_60(sqrt_s) ;
10918 double muProd1 = muProd -1.0;
10919 double muProd2 = 0.0;
10920
10921 //-- Decay:
10922 double BrHXXRatio = 1.0;
10923 double dBrHXXRatio1 = 0.0;
10924 double dBrHXXRatio2 = 0.0;
10925 if (fstate==0){
10926 // Use for Cross-section [pb] with no Higgs-boson decay
10927 weight = 0.11821; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
10928 } else if (fstate == 1){
10929 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10930 dBrHXXRatio1 = BrHXXRatio - 1.0;
10931 dBrHXXRatio2 = 0.0;
10932 } else if (fstate == 2){
10933 BrHXXRatio = (myNPbase->BrHgagaRatio());
10934 dBrHXXRatio1 = BrHXXRatio - 1.0;
10935 dBrHXXRatio2 = 0.0;
10936 } else if (fstate == 3){
10937 BrHXXRatio = (myNPbase->BrHbbRatio());
10938 dBrHXXRatio1 = BrHXXRatio - 1.0;
10939 dBrHXXRatio2 = 0.0;
10940 } else if (fstate == 4){
10941 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
10942 dBrHXXRatio1 = BrHXXRatio - 1.0;
10943 dBrHXXRatio2 = 0.0;
10944 } else {
10945 throw std::runtime_error("STXS12_ttH_pTH0_60 called with invalid argument for final state in fstate_i");
10946 }
10947
10948 //-- Production x Decay:
10949 if ((this->getModel()).isModelLinearized()){
10950 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10951 } else if((this->getModel()).isModelNPquadratic()){
10952 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10953 } else {
10954 return weight*(muProd)*(BrHXXRatio);
10955 }
10956
10957
10958}
10959
10960// -----------------------------------------------------------------------------
10961
10962//AG:STXS2024
10963STXS12_ttH_pTH60_120::STXS12_ttH_pTH60_120(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
10964: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10965{
10966 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
10967 throw std::runtime_error("STXS12_ttH_pTH60_120 called with a class whose parent is not NPbase");
10968
10969}
10970
10972{
10973 //-- Production:
10974 double weight = 1.0; //If normalized to the SM
10975 double muProd = myNPbase->STXS12_ttH_pTH60_120(sqrt_s) ;
10976 double muProd1 = muProd -1.0;
10977 double muProd2 = 0.0;
10978
10979 //-- Decay:
10980 double BrHXXRatio = 1.0;
10981 double dBrHXXRatio1 = 0.0;
10982 double dBrHXXRatio2 = 0.0;
10983 if (fstate==0){
10984 // Use for Cross-section [pb] with no Higgs-boson decay
10985 weight = 0.17813; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
10986 } else if (fstate == 1){
10987 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
10988 dBrHXXRatio1 = BrHXXRatio - 1.0;
10989 dBrHXXRatio2 = 0.0;
10990 } else if (fstate == 2){
10991 BrHXXRatio = (myNPbase->BrHgagaRatio());
10992 dBrHXXRatio1 = BrHXXRatio - 1.0;
10993 dBrHXXRatio2 = 0.0;
10994 } else if (fstate == 3){
10995 BrHXXRatio = (myNPbase->BrHbbRatio());
10996 dBrHXXRatio1 = BrHXXRatio - 1.0;
10997 dBrHXXRatio2 = 0.0;
10998 } else if (fstate == 4){
10999 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
11000 dBrHXXRatio1 = BrHXXRatio - 1.0;
11001 dBrHXXRatio2 = 0.0;
11002 } else {
11003 throw std::runtime_error("STXS12_ttH_pTH60_120 called with invalid argument for final state in fstate_i");
11004 }
11005
11006 //-- Production x Decay:
11007 if ((this->getModel()).isModelLinearized()){
11008 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11009 } else if((this->getModel()).isModelNPquadratic()){
11010 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11011 } else {
11012 return weight*(muProd)*(BrHXXRatio);
11013 }
11014
11015}
11016
11017// -----------------------------------------------------------------------------
11018
11019//AG:STXS2024
11020STXS12_ttH_pTH0_120::STXS12_ttH_pTH0_120(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
11021: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11022{
11023 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11024 throw std::runtime_error("STXS12_ttH_pTH0_120 called with a class whose parent is not NPbase");
11025
11026}
11027
11029{
11030 //-- Production:
11031 double weight = 1.0; //If normalized to the SM
11032 //Since adding bins, include partial weigths of SM_predictions
11033 //(https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.)
11034 double muProd = ( 0.11821*(myNPbase->STXS12_ttH_pTH0_60(sqrt_s) )
11035 + 0.17813*(myNPbase->STXS12_ttH_pTH60_120(sqrt_s) ) )/(0.11821+0.17813);
11036 double muProd1 = ( 0.11821*(myNPbase->STXS12_ttH_pTH0_60(sqrt_s) -1.0)
11037 + 0.17813*(myNPbase->STXS12_ttH_pTH60_120(sqrt_s)-1.0 ) )/(0.11821+0.17813);;
11038 double muProd2 = 0.0;
11039
11040 //-- Decay:
11041 double BrHXXRatio = 1.0;
11042 double dBrHXXRatio1 = 0.0;
11043 double dBrHXXRatio2 = 0.0;
11044 if (fstate==0){
11045 // Use for Cross-section [pb] with no Higgs-boson decay
11046 weight = 0.17813; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
11047 } else if (fstate == 1){
11048 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
11049 dBrHXXRatio1 = BrHXXRatio - 1.0;
11050 dBrHXXRatio2 = 0.0;
11051 } else if (fstate == 2){
11052 BrHXXRatio = (myNPbase->BrHgagaRatio());
11053 dBrHXXRatio1 = BrHXXRatio - 1.0;
11054 dBrHXXRatio2 = 0.0;
11055 } else if (fstate == 3){
11056 BrHXXRatio = (myNPbase->BrHbbRatio());
11057 dBrHXXRatio1 = BrHXXRatio - 1.0;
11058 dBrHXXRatio2 = 0.0;
11059 } else if (fstate == 4){
11060 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
11061 dBrHXXRatio1 = BrHXXRatio - 1.0;
11062 dBrHXXRatio2 = 0.0;
11063 } else {
11064 throw std::runtime_error("STXS12_ttH_pTH0_120 called with invalid argument for final state in fstate_i");
11065 }
11066
11067 //-- Production x Decay:
11068 if ((this->getModel()).isModelLinearized()){
11069 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11070 } else if((this->getModel()).isModelNPquadratic()){
11071 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11072 } else {
11073 return weight*(muProd)*(BrHXXRatio);
11074 }
11075
11076}
11077
11078// -----------------------------------------------------------------------------
11079
11080//AG:STXS2024
11081STXS12_ttH_pTH120_200::STXS12_ttH_pTH120_200(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
11082: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11083{
11084 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11085 throw std::runtime_error("STXS12_ttH_pTH120_200 called with a class whose parent is not NPbase");
11086
11087}
11088
11090{
11091 //-- Production:
11092 double weight = 1.0; //If normalized to the SM
11093 double muProd = myNPbase->STXS12_ttH_pTH120_200(sqrt_s) ;
11094 double muProd1 = muProd -1.0;
11095 double muProd2 = 0.0;
11096
11097 //-- Decay:
11098 double BrHXXRatio = 1.0;
11099 double dBrHXXRatio1 = 0.0;
11100 double dBrHXXRatio2 = 0.0;
11101 if (fstate==0){
11102 // Use for Cross-section [pb] with no Higgs-boson decay
11103 weight = 0.12647; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
11104 } else if (fstate == 1){
11105 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
11106 dBrHXXRatio1 = BrHXXRatio - 1.0;
11107 dBrHXXRatio2 = 0.0;
11108 } else if (fstate == 2){
11109 BrHXXRatio = (myNPbase->BrHgagaRatio());
11110 dBrHXXRatio1 = BrHXXRatio - 1.0;
11111 dBrHXXRatio2 = 0.0;
11112 } else if (fstate == 3){
11113 BrHXXRatio = (myNPbase->BrHbbRatio());
11114 dBrHXXRatio1 = BrHXXRatio - 1.0;
11115 dBrHXXRatio2 = 0.0;
11116 } else if (fstate == 4){
11117 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
11118 dBrHXXRatio1 = BrHXXRatio - 1.0;
11119 dBrHXXRatio2 = 0.0;
11120 } else {
11121 throw std::runtime_error("STXS12_ttH_pTH120_200 called with invalid argument for final state in fstate_i");
11122 }
11123
11124 //-- Production x Decay:
11125 if ((this->getModel()).isModelLinearized()){
11126 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11127 } else if((this->getModel()).isModelNPquadratic()){
11128 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11129 } else {
11130 return weight*(muProd)*(BrHXXRatio);
11131 }
11132
11133}
11134
11135// -----------------------------------------------------------------------------
11136
11137//AG:STXS2024
11138STXS12_ttH_pTH200_300::STXS12_ttH_pTH200_300(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
11139: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11140{
11141 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11142 throw std::runtime_error("STXS12_ttH_pTH200_300 called with a class whose parent is not NPbase");
11143
11144}
11145
11147{
11148 //-- Production:
11149 double weight = 1.0; //If normalized to the SM
11150 double muProd = myNPbase->STXS12_ttH_pTH200_300(sqrt_s) ;
11151 double muProd1 = muProd -1.0;
11152 double muProd2 = 0.0;
11153
11154 //-- Decay:
11155 double BrHXXRatio = 1.0;
11156 double dBrHXXRatio1 = 0.0;
11157 double dBrHXXRatio2 = 0.0;
11158 if (fstate==0){
11159 // Use for Cross-section [pb] with no Higgs-boson decay
11160 weight = 0.05263; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
11161 } else if (fstate == 1){
11162 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
11163 dBrHXXRatio1 = BrHXXRatio - 1.0;
11164 dBrHXXRatio2 = 0.0;
11165 } else if (fstate == 2){
11166 BrHXXRatio = (myNPbase->BrHgagaRatio());
11167 dBrHXXRatio1 = BrHXXRatio - 1.0;
11168 dBrHXXRatio2 = 0.0;
11169 } else if (fstate == 3){
11170 BrHXXRatio = (myNPbase->BrHbbRatio());
11171 dBrHXXRatio1 = BrHXXRatio - 1.0;
11172 dBrHXXRatio2 = 0.0;
11173 } else if (fstate == 4){
11174 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
11175 dBrHXXRatio1 = BrHXXRatio - 1.0;
11176 dBrHXXRatio2 = 0.0;
11177 } else {
11178 throw std::runtime_error("STXS12_ttH_pTH200_300 called with invalid argument for final state in fstate_i");
11179 }
11180
11181 //-- Production x Decay:
11182 if ((this->getModel()).isModelLinearized()){
11183 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11184 } else if((this->getModel()).isModelNPquadratic()){
11185 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11186 } else {
11187 return weight*(muProd)*(BrHXXRatio);
11188 }
11189
11190}
11191
11192// -----------------------------------------------------------------------------
11193
11194STXS12_ttH_pTH300_Inf::STXS12_ttH_pTH300_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
11195: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11196{
11197 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11198 throw std::runtime_error("STXS12_ttH_pTH300_Inf called with a class whose parent is not NPbase");
11199
11200}
11201
11203{
11204 //-- Production:
11205 double weight = 1.0; //If normalized to the SM
11206 double muProd = myNPbase->STXS12_ttH_pTH300_Inf(sqrt_s) ;
11207 double muProd1 = muProd -1.0;
11208 double muProd2 = 0.0;
11209
11210 //-- Decay:
11211 double BrHXXRatio = 1.0;
11212 double dBrHXXRatio1 = 0.0;
11213 double dBrHXXRatio2 = 0.0;
11214 if (fstate==0){
11215 // Use for Cross-section [pb] with no Higgs-boson decay
11216 weight = 1.0; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
11217 } else if (fstate == 1){
11218 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
11219 dBrHXXRatio1 = BrHXXRatio - 1.0;
11220 dBrHXXRatio2 = 0.0;
11221 } else if (fstate == 2){
11222 BrHXXRatio = (myNPbase->BrHgagaRatio());
11223 dBrHXXRatio1 = BrHXXRatio - 1.0;
11224 dBrHXXRatio2 = 0.0;
11225 } else if (fstate == 3){
11226 BrHXXRatio = (myNPbase->BrHbbRatio());
11227 dBrHXXRatio1 = BrHXXRatio - 1.0;
11228 dBrHXXRatio2 = 0.0;
11229 } else if (fstate == 4){
11230 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
11231 dBrHXXRatio1 = BrHXXRatio - 1.0;
11232 dBrHXXRatio2 = 0.0;
11233 } else {
11234 throw std::runtime_error("STXS12_ttH_pTH300_Inf called with invalid argument for final state in fstate_i");
11235 }
11236
11237 //-- Production x Decay:
11238 if ((this->getModel()).isModelLinearized()){
11239 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11240 } else if((this->getModel()).isModelNPquadratic()){
11241 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11242 } else {
11243 return weight*(muProd)*(BrHXXRatio);
11244 }
11245
11246
11247}
11248
11249// -----------------------------------------------------------------------------
11250
11251//AG:STXS2024
11252STXS12_ttH_pTH300_450::STXS12_ttH_pTH300_450(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
11253: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11254{
11255 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11256 throw std::runtime_error("STXS12_ttH_pTH300_450 called with a class whose parent is not NPbase");
11257
11258}
11259
11261{
11262 //-- Production:
11263 double weight = 1.0; //If normalized to the SM
11264 double muProd = myNPbase->STXS12_ttH_pTH300_450(sqrt_s);
11265 double muProd1 = muProd -1.0;
11266 double muProd2 = 0.0;
11267
11268 //-- Decay:
11269 double BrHXXRatio = 1.0;
11270 double dBrHXXRatio1 = 0.0;
11271 double dBrHXXRatio2 = 0.0;
11272 if (fstate==0){
11273 // Use for Cross-section [pb] with no Higgs-boson decay
11274 weight = 0.01903; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
11275 } else if (fstate == 1){
11276 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
11277 dBrHXXRatio1 = BrHXXRatio - 1.0;
11278 dBrHXXRatio2 = 0.0;
11279 } else if (fstate == 2){
11280 BrHXXRatio = (myNPbase->BrHgagaRatio());
11281 dBrHXXRatio1 = BrHXXRatio - 1.0;
11282 dBrHXXRatio2 = 0.0;
11283 } else if (fstate == 3){
11284 BrHXXRatio = (myNPbase->BrHbbRatio());
11285 dBrHXXRatio1 = BrHXXRatio - 1.0;
11286 dBrHXXRatio2 = 0.0;
11287 } else if (fstate == 4){
11288 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
11289 dBrHXXRatio1 = BrHXXRatio - 1.0;
11290 dBrHXXRatio2 = 0.0;
11291 } else if (fstate == 5){
11292 BrHXXRatio = (myNPbase->BrHtautauRatio());
11293 dBrHXXRatio1 = BrHXXRatio - 1.0;
11294 dBrHXXRatio2 = 0.0;
11295 } else {
11296 throw std::runtime_error("STXS12_ttH_pTH300_450 called with invalid argument for final state in fstate_i");
11297 }
11298
11299 //-- Production x Decay:
11300 if ((this->getModel()).isModelLinearized()){
11301 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11302 } else if((this->getModel()).isModelNPquadratic()){
11303 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11304 } else {
11305 return weight*(muProd)*(BrHXXRatio);
11306 }
11307
11308}
11309// -----------------------------------------------------------------------------
11310
11311//AG:STXS2024
11312STXS12_ttH_pTH450_Inf::STXS12_ttH_pTH450_Inf(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
11313: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11314{
11315 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11316 throw std::runtime_error("STXS12_ttH_pTH450_Inf called with a class whose parent is not NPbase");
11317
11318}
11319
11321{
11322 //-- Production:
11323 double weight = 1.0; //If normalized to the SM
11324 double muProd = myNPbase->STXS12_ttH_pTH450_Inf(sqrt_s);
11325 double muProd1 = muProd -1.0;
11326 double muProd2 = 0.0;
11327
11328 //-- Decay:
11329 double BrHXXRatio = 1.0;
11330 double dBrHXXRatio1 = 0.0;
11331 double dBrHXXRatio2 = 0.0;
11332 if (fstate==0){
11333 // Use for Cross-section [pb] with no Higgs-boson decay
11334 weight = 0.00538; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
11335 } else if (fstate == 1){
11336 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
11337 dBrHXXRatio1 = BrHXXRatio - 1.0;
11338 dBrHXXRatio2 = 0.0;
11339 } else if (fstate == 2){
11340 BrHXXRatio = (myNPbase->BrHgagaRatio());
11341 dBrHXXRatio1 = BrHXXRatio - 1.0;
11342 dBrHXXRatio2 = 0.0;
11343 } else if (fstate == 3){
11344 BrHXXRatio = (myNPbase->BrHbbRatio());
11345 dBrHXXRatio1 = BrHXXRatio - 1.0;
11346 dBrHXXRatio2 = 0.0;
11347 } else if (fstate == 4){
11348 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
11349 dBrHXXRatio1 = BrHXXRatio - 1.0;
11350 dBrHXXRatio2 = 0.0;
11351 } else if (fstate == 5){
11352 BrHXXRatio = (myNPbase->BrHtautauRatio());
11353 dBrHXXRatio1 = BrHXXRatio - 1.0;
11354 dBrHXXRatio2 = 0.0;
11355 } else {
11356 throw std::runtime_error("STXS12_ttH_pTH450_Inf called with invalid argument for final state in fstate_i");
11357 }
11358
11359 //-- Production x Decay:
11360 if ((this->getModel()).isModelLinearized()){
11361 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11362 } else if((this->getModel()).isModelNPquadratic()){
11363 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11364 } else {
11365 return weight*(muProd)*(BrHXXRatio);
11366 }
11367
11368}
11369
11370// -----------------------------------------------------------------------------
11371
11372//AG:STXS2024
11373STXS12_ttH_pTH300_Inf_add::STXS12_ttH_pTH300_Inf_add(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
11374: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11375{
11376 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11377 throw std::runtime_error("STXS12_ttH_pTH300_Inf_add called with a class whose parent is not NPbase");
11378
11379}
11380
11382{
11383 //-- Production:
11384 double weight = 1.0; //If normalized to the SM
11385 //Since adding bins, include partial weigths of SM_predictions
11386 //(https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.)
11387 double muProd = (0.01903*myNPbase->STXS12_ttH_pTH300_450(sqrt_s)
11388 + 0.00538*myNPbase->STXS12_ttH_pTH450_Inf(sqrt_s)) / (0.01903+0.00538);
11389 double muProd1 = (0.01903*(myNPbase->STXS12_ttH_pTH300_450(sqrt_s)-1.0)
11390 + 0.00538*(myNPbase->STXS12_ttH_pTH450_Inf(sqrt_s)-1.0)) / (0.01903+0.00538);
11391 double muProd2 = 0.0;
11392
11393 //-- Decay:
11394 double BrHXXRatio = 1.0;
11395 double dBrHXXRatio1 = 0.0;
11396 double dBrHXXRatio2 = 0.0;
11397 if (fstate==0){
11398 // Use for Cross-section [pb] with no Higgs-boson decay
11399 weight = 0.00538; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
11400 } else if (fstate == 1){
11401 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
11402 dBrHXXRatio1 = BrHXXRatio - 1.0;
11403 dBrHXXRatio2 = 0.0;
11404 } else if (fstate == 2){
11405 BrHXXRatio = (myNPbase->BrHgagaRatio());
11406 dBrHXXRatio1 = BrHXXRatio - 1.0;
11407 dBrHXXRatio2 = 0.0;
11408 } else if (fstate == 3){
11409 BrHXXRatio = (myNPbase->BrHbbRatio());
11410 dBrHXXRatio1 = BrHXXRatio - 1.0;
11411 dBrHXXRatio2 = 0.0;
11412 } else if (fstate == 4){
11413 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
11414 dBrHXXRatio1 = BrHXXRatio - 1.0;
11415 dBrHXXRatio2 = 0.0;
11416 } else if (fstate == 5){
11417 BrHXXRatio = (myNPbase->BrHtautauRatio());
11418 dBrHXXRatio1 = BrHXXRatio - 1.0;
11419 dBrHXXRatio2 = 0.0;
11420 } else {
11421 throw std::runtime_error("STXS12_ttH_pTH300_Inf_add called with invalid argument for final state in fstate_i");
11422 }
11423
11424 //-- Production x Decay:
11425 if ((this->getModel()).isModelLinearized()){
11426 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11427 } else if((this->getModel()).isModelNPquadratic()){
11428 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11429 } else {
11430 return weight*(muProd)*(BrHXXRatio);
11431 }
11432
11433}
11434
11435// -----------------------------------------------------------------------------
11436
11437//AG:STXS2024
11438STXS12_ttH::STXS12_ttH(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i) //AG:added
11439: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11440{
11441 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11442 throw std::runtime_error("STXS12_ttH called with a class whose parent is not NPbase");
11443
11444}
11445
11447{
11448 //-- Production:
11449 double weight = 1.0; //If normalized to the SM
11450 //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
11451 //Since adding bins, include partial weigths (SM_predictions)
11452 double muProd = ( 0.09779*myNPbase->STXS12_ttH_pTH0_60(sqrt_s)
11457 + 0.00060*myNPbase->STXS12_ttH_pTH450_Inf(sqrt_s) ) /(0.09779 + 0.13884 + 0.05439 + 0.05303 + 0.00498 + 0.00060 );
11458 double muProd1 = ( 0.09779*(myNPbase->STXS12_ttH_pTH0_60(sqrt_s)-1.0)
11459 + 0.13884*(myNPbase->STXS12_ttH_pTH60_120(sqrt_s)-1.0)
11460 + 0.05439*(myNPbase->STXS12_ttH_pTH120_200(sqrt_s)-1.0)
11461 + 0.05303*(myNPbase->STXS12_ttH_pTH200_300(sqrt_s)-1.0)
11462 + 0.00498*(myNPbase->STXS12_ttH_pTH300_450(sqrt_s)-1.0)
11463 + 0.00060*(myNPbase->STXS12_ttH_pTH450_Inf(sqrt_s)-1.0) ) /(0.09779 + 0.13884 + 0.05439 + 0.05303 + 0.00498 + 0.00060 );
11464 double muProd2 = 0.0;
11465
11466 //-- Decay:
11467 double BrHXXRatio = 1.0;
11468 double dBrHXXRatio1 = 0.0;
11469 double dBrHXXRatio2 = 0.0;
11470 if (fstate==0){
11471 weight = 1.0;
11472 } else if (fstate == 1){
11473 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
11474 dBrHXXRatio1 = BrHXXRatio - 1.0;
11475 dBrHXXRatio2 = 0.0;
11476 } else if (fstate == 2){
11477 BrHXXRatio = (myNPbase->BrHgagaRatio());
11478 dBrHXXRatio1 = BrHXXRatio - 1.0;
11479 dBrHXXRatio2 = 0.0;
11480 } else if (fstate == 3){
11481 BrHXXRatio = (myNPbase->BrHbbRatio());
11482 dBrHXXRatio1 = BrHXXRatio - 1.0;
11483 dBrHXXRatio2 = 0.0;
11484 } else if (fstate == 4){
11485 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
11486 dBrHXXRatio1 = BrHXXRatio - 1.0;
11487 dBrHXXRatio2 = 0.0;
11488 } else if (fstate == 5){
11489 BrHXXRatio = (myNPbase->BrHtautauRatio());
11490 dBrHXXRatio1 = BrHXXRatio - 1.0;
11491 dBrHXXRatio2 = 0.0;
11492 } else if (fstate == 6){
11493 BrHXXRatio = (myNPbase->BrHWWRatio());
11494 dBrHXXRatio1 = BrHXXRatio - 1.0;
11495 dBrHXXRatio2 = 0.0;
11496 } else if (fstate == 7){
11497 BrHXXRatio = (myNPbase->BrHZZRatio());
11498 dBrHXXRatio1 = BrHXXRatio - 1.0;
11499 dBrHXXRatio2 = 0.0;
11500 } else {
11501 throw std::runtime_error("STXS12_ttH called with invalid argument for final state in fstate_i");
11502 }
11503
11504 //-- Production x Decay:
11505 if ((this->getModel()).isModelLinearized()){
11506 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11507 } else if((this->getModel()).isModelNPquadratic()){
11508 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11509 } else {
11510 return weight*(muProd)*(BrHXXRatio);
11511 }
11512
11513}
11514
11515// -----------------------------------------------------------------------------
11516
11517//AG:STXS2024
11518STXS12_tH::STXS12_tH(const StandardModel& SM_i, const double sqrt_s_i, unsigned int fstate_i)
11519: ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11520{
11521 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11522 throw std::runtime_error("STXS12_tH called with a class whose parent is not NPbase");
11523
11524}
11525
11526double STXS12_tH::computeThValue() //AG:modified
11527{
11528 //-- Production:
11529 double weight = 1.0; //If normalized to the SM
11530 double muProd = myNPbase->STXS12_tH(sqrt_s);
11531 double muProd1 = muProd -1.0;
11532 double muProd2 = 0.0;
11533
11534 //-- Decay:
11535 double BrHXXRatio = 1.0;
11536 double dBrHXXRatio1 = 0.0;
11537 double dBrHXXRatio2 = 0.0;
11538 if (fstate==0){
11539 // Use for Cross-section [pb] with no Higgs-boson decay
11540 weight = 0.08207; //Ref: https://www.hepdata.net/record/ins2104706 Figure7. After symmetrizing.
11541 } else if (fstate == 1){
11542 BrHXXRatio = (myNPbase->STXS12_BrH4lRatio());
11543 dBrHXXRatio1 = BrHXXRatio - 1.0;
11544 dBrHXXRatio2 = 0.0;
11545 } else if (fstate == 2){
11546 BrHXXRatio = (myNPbase->BrHgagaRatio());
11547 dBrHXXRatio1 = BrHXXRatio - 1.0;
11548 dBrHXXRatio2 = 0.0;
11549 } else if (fstate == 3){
11550 BrHXXRatio = (myNPbase->BrHbbRatio());
11551 dBrHXXRatio1 = BrHXXRatio - 1.0;
11552 dBrHXXRatio2 = 0.0;
11553 } else if (fstate == 4){
11554 BrHXXRatio = (myNPbase->STXS12_BrHevmuvRatio());
11555 dBrHXXRatio1 = BrHXXRatio - 1.0;
11556 dBrHXXRatio2 = 0.0;
11557 } else if (fstate == 5){
11558 BrHXXRatio = (myNPbase->BrHtautauRatio());
11559 dBrHXXRatio1 = BrHXXRatio - 1.0;
11560 dBrHXXRatio2 = 0.0;
11561 } else {
11562 throw std::runtime_error("STXS12_tH called with invalid argument for final state in fstate_i");
11563 }
11564
11565 //-- Production x Decay:
11566 if ((this->getModel()).isModelLinearized()){
11567 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11568 } else if((this->getModel()).isModelNPquadratic()){
11569 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11570 } else {
11571 return weight*(muProd)*(BrHXXRatio);
11572 }
11573
11574
11575}
11576
11577// -----------------------------------------------------------------------------
11578
11579
11580//-----------------------------------------------------------------------------------------
11581//-- Special Hadron collider signal strengths with separate full TH unc U(prod x decay) ---
11582//-----------------------------------------------------------------------------------------
11583
11584
11585muTHUggHgaga::muTHUggHgaga(const StandardModel& SM_i, const double sqrt_s_i)
11586: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11587{
11588 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11589 throw std::runtime_error("muTHUggHgaga called with a class whose parent is not NPbase");
11590}
11591
11593{
11594 return myNPbase->muTHUggHgaga(sqrt_s);
11595}
11596
11597
11598muTHUVBFHgaga::muTHUVBFHgaga(const StandardModel& SM_i, const double sqrt_s_i)
11599: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11600{
11601 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11602 throw std::runtime_error("muTHUVBFHgaga called with a class whose parent is not NPbase");
11603}
11604
11606{
11607 return myNPbase->muTHUVBFHgaga(sqrt_s);
11608}
11609
11610muTHUZHgaga::muTHUZHgaga(const StandardModel& SM_i, const double sqrt_s_i)
11611: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11612{
11613 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11614 throw std::runtime_error("muTHUZHgaga called with a class whose parent is not NPbase");
11615}
11616
11618{
11619 return myNPbase->muTHUZHgaga(sqrt_s);
11620}
11621
11622muTHUWHgaga::muTHUWHgaga(const StandardModel& SM_i, const double sqrt_s_i)
11623: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11624{
11625 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11626 throw std::runtime_error("muTHUWHgaga called with a class whose parent is not NPbase");
11627}
11628
11630{
11631 return myNPbase->muTHUWHgaga(sqrt_s);
11632}
11633
11634muTHUVHgaga::muTHUVHgaga(const StandardModel& SM_i, const double sqrt_s_i)
11635: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11636{
11637 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11638 throw std::runtime_error("muTHUVHgaga called with a class whose parent is not NPbase");
11639}
11640
11642{
11643 return myNPbase->muTHUVHgaga(sqrt_s);
11644}
11645
11646muTHUttHgaga::muTHUttHgaga(const StandardModel& SM_i, const double sqrt_s_i)
11647: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11648{
11649 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11650 throw std::runtime_error("muTHUttHgaga called with a class whose parent is not NPbase");
11651}
11652
11654{
11655 return myNPbase->muTHUttHgaga(sqrt_s);
11656}
11657
11658muTHUggHZga::muTHUggHZga(const StandardModel& SM_i, const double sqrt_s_i)
11659: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11660{
11661 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11662 throw std::runtime_error("muTHUggHZga called with a class whose parent is not NPbase");
11663}
11664
11666{
11667 return myNPbase->muTHUggHZga(sqrt_s);
11668}
11669
11670muTHUggHZgamumu::muTHUggHZgamumu(const StandardModel& SM_i, const double sqrt_s_i)
11671: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11672{
11673 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11674 throw std::runtime_error("muTHUggHZgamumu called with a class whose parent is not NPbase");
11675}
11676
11678{
11679 return (myNPbase->muTHUggHZgamumu(sqrt_s));
11680}
11681
11682muTHUVBFHZga::muTHUVBFHZga(const StandardModel& SM_i, const double sqrt_s_i)
11683: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11684{
11685 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11686 throw std::runtime_error("muTHUVBFHZga called with a class whose parent is not NPbase");
11687}
11688
11690{
11691
11692 return myNPbase->muTHUVBFHZga(sqrt_s);
11693}
11694
11695muTHUZHZga::muTHUZHZga(const StandardModel& SM_i, const double sqrt_s_i)
11696: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11697{
11698 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11699 throw std::runtime_error("muTHUZHZga called with a class whose parent is not NPbase");
11700}
11701
11703{
11704 return myNPbase->muTHUZHZga(sqrt_s);
11705}
11706
11707muTHUWHZga::muTHUWHZga(const StandardModel& SM_i, const double sqrt_s_i)
11708: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11709{
11710 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11711 throw std::runtime_error("muTHUWHZga called with a class whose parent is not NPbase");
11712}
11713
11715{
11716 return myNPbase->muTHUWHZga(sqrt_s);
11717}
11718
11719muTHUVHZga::muTHUVHZga(const StandardModel& SM_i, const double sqrt_s_i)
11720: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11721{
11722 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11723 throw std::runtime_error("muTHUVHZga called with a class whose parent is not NPbase");
11724}
11725
11727{
11728 return myNPbase->muTHUVHZga(sqrt_s);
11729}
11730
11731muTHUttHZga::muTHUttHZga(const StandardModel& SM_i, const double sqrt_s_i)
11732: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11733{
11734 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11735 throw std::runtime_error("muTHUttHZga called with a class whose parent is not NPbase");
11736}
11737
11739{
11740 return myNPbase->muTHUttHZga(sqrt_s);
11741}
11742
11743muTHUggHZZ::muTHUggHZZ(const StandardModel& SM_i, const double sqrt_s_i)
11744: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11745{
11746 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11747 throw std::runtime_error("muTHUggHZZ called with a class whose parent is not NPbase");
11748}
11749
11751{
11752 return myNPbase->muTHUggHZZ(sqrt_s);
11753}
11754
11755muTHUVBFHZZ::muTHUVBFHZZ(const StandardModel& SM_i, const double sqrt_s_i)
11756: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11757{
11758 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11759 throw std::runtime_error("muTHUVBFHZZ called with a class whose parent is not NPbase");
11760}
11761
11763{
11764 return myNPbase->muTHUVBFHZZ(sqrt_s);
11765}
11766
11767muTHUZHZZ::muTHUZHZZ(const StandardModel& SM_i, const double sqrt_s_i)
11768: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11769{
11770 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11771 throw std::runtime_error("muTHUZHZZ called with a class whose parent is not NPbase");
11772}
11773
11775{
11776 return myNPbase->muTHUZHZZ(sqrt_s);
11777}
11778
11779muTHUWHZZ::muTHUWHZZ(const StandardModel& SM_i, const double sqrt_s_i)
11780: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11781{
11782 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11783 throw std::runtime_error("muTHUWHZZ called with a class whose parent is not NPbase");
11784}
11785
11787{
11788 return myNPbase->muTHUWHZZ(sqrt_s);
11789}
11790
11791muTHUVHZZ::muTHUVHZZ(const StandardModel& SM_i, const double sqrt_s_i)
11792: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11793{
11794 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11795 throw std::runtime_error("muTHUVHZZ called with a class whose parent is not NPbase");
11796}
11797
11799{
11800 return myNPbase->muTHUVHZZ(sqrt_s);
11801}
11802
11803muTHUttHZZ::muTHUttHZZ(const StandardModel& SM_i, const double sqrt_s_i)
11804: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11805{
11806 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11807 throw std::runtime_error("muTHUttHZZ called with a class whose parent is not NPbase");
11808}
11809
11811{
11812 return myNPbase->muTHUttHZZ(sqrt_s);
11813}
11814
11815muTHUggHZZ4l::muTHUggHZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
11816: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11817{
11818 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11819 throw std::runtime_error("muTHUggHZZ4l called with a class whose parent is not NPbase");
11820}
11821
11823{
11824 return myNPbase->muTHUggHZZ4l(sqrt_s);
11825}
11826
11827muTHUggHZZ4mu::muTHUggHZZ4mu(const StandardModel& SM_i, const double sqrt_s_i)
11828: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11829{
11830 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11831 throw std::runtime_error("muTHUggHZZ4mu called with a class whose parent is not NPbase");
11832}
11833
11835{
11836 return (myNPbase->muTHUggHZZ4mu(sqrt_s));
11837}
11838
11839muTHUVBFHZZ4l::muTHUVBFHZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
11840: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11841{
11842 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11843 throw std::runtime_error("muTHUVBFHZZ4l called with a class whose parent is not NPbase");
11844}
11845
11847{
11848 return myNPbase->muTHUVBFHZZ4l(sqrt_s);
11849}
11850
11851muTHUZHZZ4l::muTHUZHZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
11852: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11853{
11854 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11855 throw std::runtime_error("muTHUZHZZ4l called with a class whose parent is not NPbase");
11856}
11857
11859{
11860 return myNPbase->muTHUZHZZ4l(sqrt_s);
11861}
11862
11863muTHUWHZZ4l::muTHUWHZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
11864: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11865{
11866 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11867 throw std::runtime_error("muTHUWHZZ4l called with a class whose parent is not NPbase");
11868}
11869
11871{
11872 return myNPbase->muTHUWHZZ4l(sqrt_s);
11873}
11874
11875muTHUVHZZ4l::muTHUVHZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
11876: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11877{
11878 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11879 throw std::runtime_error("muTHUVHZZ4l called with a class whose parent is not NPbase");
11880}
11881
11883{
11884 return myNPbase->muTHUVHZZ4l(sqrt_s);
11885}
11886
11887muTHUttHZZ4l::muTHUttHZZ4l(const StandardModel& SM_i, const double sqrt_s_i)
11888: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11889{
11890 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11891 throw std::runtime_error("muTHUttHZZ4l called with a class whose parent is not NPbase");
11892}
11893
11895{
11896 return myNPbase->muTHUttHZZ4l(sqrt_s);
11897}
11898
11899muTHUggHWW::muTHUggHWW(const StandardModel& SM_i, const double sqrt_s_i)
11900: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11901{
11902 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11903 throw std::runtime_error("muTHUggHWW called with a class whose parent is not NPbase");
11904}
11905
11907{
11908 return myNPbase->muTHUggHWW(sqrt_s);
11909}
11910
11911muTHUVBFHWW::muTHUVBFHWW(const StandardModel& SM_i, const double sqrt_s_i)
11912: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11913{
11914 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11915 throw std::runtime_error("muTHUVBFHWW called with a class whose parent is not NPbase");
11916}
11917
11919{
11920 return myNPbase->muTHUVBFHWW(sqrt_s);
11921}
11922
11923muTHUZHWW::muTHUZHWW(const StandardModel& SM_i, const double sqrt_s_i)
11924: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11925{
11926 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11927 throw std::runtime_error("muTHUZHWW called with a class whose parent is not NPbase");
11928}
11929
11931{
11932 return myNPbase->muTHUZHWW(sqrt_s);
11933}
11934
11935muTHUWHWW::muTHUWHWW(const StandardModel& SM_i, const double sqrt_s_i)
11936: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11937{
11938 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11939 throw std::runtime_error("muTHUWHWW called with a class whose parent is not NPbase");
11940}
11941
11943{
11944 return myNPbase->muTHUWHWW(sqrt_s);
11945}
11946
11947muTHUVHWW::muTHUVHWW(const StandardModel& SM_i, const double sqrt_s_i)
11948: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11949{
11950 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11951 throw std::runtime_error("muTHUVHWW called with a class whose parent is not NPbase");
11952}
11953
11955{
11956 return myNPbase->muTHUVHWW(sqrt_s);
11957}
11958
11959muTHUttHWW::muTHUttHWW(const StandardModel& SM_i, const double sqrt_s_i)
11960: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11961{
11962 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11963 throw std::runtime_error("muTHUttHWW called with a class whose parent is not NPbase");
11964}
11965
11967{
11968 return myNPbase->muTHUttHWW(sqrt_s);
11969}
11970
11971muTHUggHWW2l2v::muTHUggHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
11972: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11973{
11974 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11975 throw std::runtime_error("muTHUggHWW2l2v called with a class whose parent is not NPbase");
11976}
11977
11979{
11981}
11982
11983muTHUVBFHWW2l2v::muTHUVBFHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
11984: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11985{
11986 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11987 throw std::runtime_error("muTHUVBFHWW2l2v called with a class whose parent is not NPbase");
11988}
11989
11991{
11993}
11994
11995muTHUZHWW2l2v::muTHUZHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
11996: ThObservable(SM_i), sqrt_s(sqrt_s_i)
11997{
11998 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
11999 throw std::runtime_error("muTHUZHWW2l2v called with a class whose parent is not NPbase");
12000}
12001
12003{
12004 return myNPbase->muTHUZHWW2l2v(sqrt_s);
12005}
12006
12007muTHUWHWW2l2v::muTHUWHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
12008: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12009{
12010 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12011 throw std::runtime_error("muTHUWHWW2l2v called with a class whose parent is not NPbase");
12012}
12013
12015{
12016 return myNPbase->muTHUWHWW2l2v(sqrt_s);
12017}
12018
12019muTHUVHWW2l2v::muTHUVHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
12020: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12021{
12022 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12023 throw std::runtime_error("muTHUVHWW2l2v called with a class whose parent is not NPbase");
12024}
12025
12027{
12028 return myNPbase->muTHUVHWW2l2v(sqrt_s);
12029}
12030
12031muTHUttHWW2l2v::muTHUttHWW2l2v(const StandardModel& SM_i, const double sqrt_s_i)
12032: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12033{
12034 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12035 throw std::runtime_error("muTHUttHWW2l2v called with a class whose parent is not NPbase");
12036}
12037
12039{
12041}
12042
12043muTHUggHmumu::muTHUggHmumu(const StandardModel& SM_i, const double sqrt_s_i)
12044: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12045{
12046 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12047 throw std::runtime_error("muTHUggHmumu called with a class whose parent is not NPbase");
12048}
12049
12051{
12052 return myNPbase->muTHUggHmumu(sqrt_s);
12053}
12054
12055muTHUVBFHmumu::muTHUVBFHmumu(const StandardModel& SM_i, const double sqrt_s_i)
12056: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12057{
12058 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12059 throw std::runtime_error("muTHUVBFHmumu called with a class whose parent is not NPbase");
12060}
12061
12063{
12064 return myNPbase->muTHUVBFHmumu(sqrt_s);
12065}
12066
12067muTHUZHmumu::muTHUZHmumu(const StandardModel& SM_i, const double sqrt_s_i)
12068: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12069{
12070 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12071 throw std::runtime_error("muTHUZHmumu called with a class whose parent is not NPbase");
12072}
12073
12075{
12076 return myNPbase->muTHUZHmumu(sqrt_s);
12077}
12078
12079muTHUWHmumu::muTHUWHmumu(const StandardModel& SM_i, const double sqrt_s_i)
12080: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12081{
12082 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12083 throw std::runtime_error("muTHUWHmumu called with a class whose parent is not NPbase");
12084}
12085
12087{
12088 return myNPbase->muTHUWHmumu(sqrt_s);
12089}
12090
12091muTHUVHmumu::muTHUVHmumu(const StandardModel& SM_i, const double sqrt_s_i)
12092: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12093{
12094 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12095 throw std::runtime_error("muTHUVHmumu called with a class whose parent is not NPbase");
12096}
12097
12099{
12100 return myNPbase->muTHUVHmumu(sqrt_s);
12101}
12102
12103muTHUttHmumu::muTHUttHmumu(const StandardModel& SM_i, const double sqrt_s_i)
12104: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12105{
12106 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12107 throw std::runtime_error("muTHUttHmumu called with a class whose parent is not NPbase");
12108}
12109
12111{
12112 return myNPbase->muTHUttHmumu(sqrt_s);
12113}
12114
12115muTHUggHtautau::muTHUggHtautau(const StandardModel& SM_i, const double sqrt_s_i)
12116: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12117{
12118 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12119 throw std::runtime_error("muTHUggHtautau called with a class whose parent is not NPbase");
12120}
12121
12123{
12125}
12126
12127muTHUVBFHtautau::muTHUVBFHtautau(const StandardModel& SM_i, const double sqrt_s_i)
12128: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12129{
12130 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12131 throw std::runtime_error("muTHUVBFHtautau called with a class whose parent is not NPbase");
12132}
12133
12135{
12137}
12138
12139muTHUZHtautau::muTHUZHtautau(const StandardModel& SM_i, const double sqrt_s_i)
12140: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12141{
12142 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12143 throw std::runtime_error("muTHUZHtautau called with a class whose parent is not NPbase");
12144}
12145
12147{
12148 return myNPbase->muTHUZHtautau(sqrt_s);
12149}
12150
12151muTHUWHtautau::muTHUWHtautau(const StandardModel& SM_i, const double sqrt_s_i)
12152: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12153{
12154 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12155 throw std::runtime_error("muTHUWHtautau called with a class whose parent is not NPbase");
12156}
12157
12159{
12160 return myNPbase->muTHUWHtautau(sqrt_s);
12161}
12162
12163muTHUVHtautau::muTHUVHtautau(const StandardModel& SM_i, const double sqrt_s_i)
12164: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12165{
12166 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12167 throw std::runtime_error("muTHUVHtautau called with a class whose parent is not NPbase");
12168}
12169
12171{
12172 return myNPbase->muTHUVHtautau(sqrt_s);
12173}
12174
12175muTHUttHtautau::muTHUttHtautau(const StandardModel& SM_i, const double sqrt_s_i)
12176: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12177{
12178 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12179 throw std::runtime_error("muTHUttHtautau called with a class whose parent is not NPbase");
12180}
12181
12183{
12185}
12186
12187muTHUggHbb::muTHUggHbb(const StandardModel& SM_i, const double sqrt_s_i)
12188: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12189{
12190 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12191 throw std::runtime_error("muTHUggHbb called with a class whose parent is not NPbase");
12192}
12193
12195{
12196 return myNPbase->muTHUggHbb(sqrt_s);
12197}
12198
12199muTHUVBFHbb::muTHUVBFHbb(const StandardModel& SM_i, const double sqrt_s_i)
12200: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12201{
12202 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12203 throw std::runtime_error("muTHUVBFHbb called with a class whose parent is not NPbase");
12204}
12205
12207{
12208 return myNPbase->muTHUVBFHbb(sqrt_s);
12209}
12210
12211muTHUZHbb::muTHUZHbb(const StandardModel& SM_i, const double sqrt_s_i)
12212: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12213{
12214 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12215 throw std::runtime_error("muTHUZHbb called with a class whose parent is not NPbase");
12216}
12217
12219{
12220 return myNPbase->muTHUZHbb(sqrt_s);
12221}
12222
12223muTHUWHbb::muTHUWHbb(const StandardModel& SM_i, const double sqrt_s_i)
12224: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12225{
12226 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12227 throw std::runtime_error("muTHUWHbb called with a class whose parent is not NPbase");
12228}
12229
12231{
12232 return myNPbase->muTHUWHbb(sqrt_s);
12233}
12234
12235muTHUVHbb::muTHUVHbb(const StandardModel& SM_i, const double sqrt_s_i)
12236: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12237{
12238 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12239 throw std::runtime_error("muTHUVHbb called with a class whose parent is not NPbase");
12240}
12241
12243{
12244 return myNPbase->muTHUVHbb(sqrt_s);
12245}
12246
12247muTHUttHbb::muTHUttHbb(const StandardModel& SM_i, const double sqrt_s_i)
12248: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12249{
12250 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12251 throw std::runtime_error("muTHUttHbb called with a class whose parent is not NPbase");
12252}
12253
12255{
12256 return myNPbase->muTHUttHbb(sqrt_s);
12257}
12258
12259
12260muTHUVBFBRinv::muTHUVBFBRinv(const StandardModel& SM_i, const double sqrt_s_i)
12261: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12262{
12263 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12264 throw std::runtime_error("muTHUVBFBRinv called with a class whose parent is not NPbase");
12265}
12266
12268{
12269
12270 return (myNPbase->muTHUVBFBRinv(sqrt_s));
12271
12272}
12273
12274muTHUVBFHinv::muTHUVBFHinv(const StandardModel& SM_i, const double sqrt_s_i)
12275: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12276{
12277 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12278 throw std::runtime_error("muTHUVBFHinv called with a class whose parent is not NPbase");
12279}
12280
12282{
12283
12284 return (myNPbase->muTHUVBFHinv(sqrt_s));
12285
12286}
12287
12288
12289muTHUVHBRinv::muTHUVHBRinv(const StandardModel& SM_i, const double sqrt_s_i)
12290: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12291{
12292 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12293 throw std::runtime_error("muTHUVHBRinv called with a class whose parent is not NPbase");
12294}
12295
12297{
12298
12299 return (myNPbase->muTHUVHBRinv(sqrt_s));
12300
12301}
12302
12303muTHUVHinv::muTHUVHinv(const StandardModel& SM_i, const double sqrt_s_i)
12304: ThObservable(SM_i), sqrt_s(sqrt_s_i)
12305{
12306 if ((myNPbase = dynamic_cast<const NPbase*> (&SM)) == NULL)
12307 throw std::runtime_error("muTHUVHinv called with a class whose parent is not NPbase");
12308}
12309
12311{
12312 return (myNPbase->muTHUVHinv(sqrt_s));
12313}
double computeThValue()
A method to compute the branching ratio of Higgs decays into exotics (invisible or not).
BrHexotic(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
BrHinvisible(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the branching ratio of Higgs decays into invisible particles.
const NPbase * myNPbase
double computeThValue()
A method to compute the branching ratio of Higgs decays into invisible particles (only decays into ne...
const NPbase * myNPbase
BrHinvisibleNP(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHto2e2muRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
BrHto2e2vRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
BrHto2l2v_over_4l_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio Br Br in the current model and in the Standard Model.
BrHto2l2v_over_gaga_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHto2l2vRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
BrHto2mu2vRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
const NPbase * myNPbase
BrHto4eRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHto4l_over_gaga_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br with in the current model and in the Standard Model.
BrHto4lRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
BrHto4muRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtoVVRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
BrHtoWWRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
const NPbase * myNPbase
BrHtoZZRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtoZga_over_4l_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
BrHtoZga_over_gaga_Ratio(const StandardModel &SM_i)
Constructor.
BrHtoZga_over_mumu_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtoZgaRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtoZgaeeRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtoZgallRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtoZgamumuRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
BrHtoZmumuga_over_mumu_Ratio(const StandardModel &SM_i)
Constructor.
BrHtobb_over_4l_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
BrHtobb_over_cc_Ratio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
BrHtobbRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtoccRatio(const StandardModel &SM_i)
Constructor.
BrHtoevmuvRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtogaga_over_2e2mu_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
BrHtogaga_over_4l_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
BrHtogaga_over_gg_Ratio(const StandardModel &SM_i)
Constructor.
BrHtogaga_over_mumu_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtogagaRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
BrHtogg_over_bb_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
BrHtogg_over_cc_Ratio(const StandardModel &SM_i)
Constructor.
BrHtoggRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
const NPbase * myNPbase
BrHtoinvRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br , in the current model and in the Standard Model.
BrHtoll_vvorjjRatio(const StandardModel &SM_i)
Constructor.
BrHtolljjRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br , in the current model and in the Standard Model.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Br , in the current model and in the Standard Model.
BrHtolv_lvorjjRatio(const StandardModel &SM_i)
Constructor.
BrHtolvjjRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Br , in the current model and in the Standard Model.
BrHtomumu_over_4l_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
BrHtomumu_over_4mu_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
BrHtomumu_over_gaga_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
BrHtomumuRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtotautau_over_4l_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
const NPbase * myNPbase
BrHtotautauRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtovisRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the Higgs width in the current model and in the Standard Model.
GammaHRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
GammaHtoWWRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the in the current model and in the Standard Model.
GammaHtoZZRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
GammaHtoZgaRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the in the current model and in the Standard Model.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the in the current model and in the Standard Model.
GammaHtobbRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the in the current model and in the Standard Model.
GammaHtoccRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
GammaHtogagaRatio(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the the ratio of the in the current model and in the Standard Model.
GammaHtoggRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the in the current model and in the Standard Model.
const NPbase * myNPbase
GammaHtomumuRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the in the current model and in the Standard Model.
const NPbase * myNPbase
const NPbase * myNPbase
GammaHtossRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the in the current model and in the Standard Model.
GammaHtotautauRatio(const StandardModel &SM_i)
Constructor.
The auxiliary base model class for other model classes.
Definition: NPbase.h:66
virtual const double muggHbb(const double sqrt_s) const
Definition: NPbase.h:1839
virtual const double muVHWW2l2v(const double sqrt_s) const
Definition: NPbase.h:1763
virtual const double STXS12_ggH_pTH450_Inf(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3994
virtual const double STXS_qqHll_pTV_0_150(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3599
virtual const double cbminuscc() const
Definition: NPbase.h:2788
virtual const double muTHUZHmumu(const double sqrt_s) const
Definition: NPbase.h:2974
virtual const double STXS12_qqHlv_pTV150_250_Nj1(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4269
virtual const double deltaGammaHtautauRatio1() const
Definition: NPbase.h:2020
virtual const double STXS12_qqHll_pTV0_150(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4359
virtual const double BrH4eRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2461
virtual const double mueeHvv(const double sqrt_s) const
The ratio between the associated production cross-section in the current model and in the Standard ...
Definition: NPbase.h:1162
virtual const double STXS12_ggH_mjj0_350_pTH0_60_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3890
virtual const double muTHUttHWW(const double sqrt_s) const
Definition: NPbase.h:2938
virtual const double muTHUttHZga(const double sqrt_s) const
Definition: NPbase.h:2864
virtual const double BrH2evRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2569
virtual const double muTHUttHbb(const double sqrt_s) const
Definition: NPbase.h:3034
virtual const double STXS12_ggH_pTH450_650(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4005
virtual const double muggHZga(const double sqrt_s) const
Definition: NPbase.h:1634
virtual const double STXS_ggH_VBFtopo_j3(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3379
virtual const double cVpluscb() const
Definition: NPbase.h:2770
virtual const double deltaGammaHtautauRatio2() const
Definition: NPbase.h:2024
virtual const double STXS12_ggH_mjj0_350_pTH60_120_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3899
virtual const double muVH(const double sqrt_s) const
The ratio between the WH+ZH associated production cross-section in the current model and in the Stan...
Definition: NPbase.h:1383
virtual const double muttHptH_HWW(const double sqrt_s) const
Definition: NPbase.h:1743
virtual const double mueeWBF(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: NPbase.h:1137
virtual const double STXS12_ggHll_pTV250_Inf(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4066
virtual const double STXS12_qqHqq_mjj350_700_pTH0_200_pTHjj0_25_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4152
virtual const double STXS12_ggH_pTH300_450(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3984
virtual const double STXS_ggH1j_pTH_200(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3425
virtual const double delta_mutH_2(const double sqrt_s) const
Definition: NPbase.h:1943
virtual const double muttH(const double sqrt_s) const
The ratio between the t-tbar-Higgs associated production cross-section in the current model and in t...
Definition: NPbase.h:1418
virtual const double muVBF(const double sqrt_s) const
The ratio between the vector-boson fusion Higgs production cross-section in the current model and in...
Definition: NPbase.h:1113
virtual const double BrHZgaRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2211
virtual const double STXS12_qqHqq_Nj0(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4098
virtual const double mummZH(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: NPbase.h:1523
virtual const double muepWBF(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: NPbase.h:1212
virtual const double STXS_ggH2j_pTH_200(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3474
virtual const double mummttH(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: NPbase.h:1559
virtual const double GammaHccRatio() const
The ratio of the in the current model and in the Standard Model.
Definition: NPbase.h:2129
virtual const double muttHZZ4l(const double sqrt_s) const
Definition: NPbase.h:1710
virtual const double muVHZga(const double sqrt_s) const
Definition: NPbase.h:1650
virtual const double muggHpbbH_Htautau(const double sqrt_s) const
Definition: NPbase.h:1811
virtual const double muTHUZHZZ(const double sqrt_s) const
Definition: NPbase.h:2876
virtual const double STXS_qqHll_pTV_150_250_1j(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3628
virtual const double muZHmumu(const double sqrt_s) const
Definition: NPbase.h:1779
virtual const double STXS12_qqHlv_pTV75_150(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4251
virtual const double STXS12_BrHbbRatio() const
The STXS BR .
Definition: NPbase.h:3776
virtual const double ccminusctau() const
Definition: NPbase.h:2806
virtual const double muTHUttHZZ(const double sqrt_s) const
Definition: NPbase.h:2888
virtual const double STXS12_qqHqq_mjj350_Inf_pTH200_Inf_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4143
virtual const double STXS_qqHqq_VBFtopo_j3(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3504
virtual const double muVBFHmumu(const double sqrt_s) const
Definition: NPbase.h:1775
virtual const double STXS12_ttH_pTH0_60(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4386
virtual const double muggHZZ4l(const double sqrt_s) const
Definition: NPbase.h:1690
virtual const double delta_muZH_2(const double sqrt_s) const
Definition: NPbase.h:1916
virtual const double cgaplusct() const
Definition: NPbase.h:2752
virtual const double muTHUVBFBRinv(const double sqrt_s) const
Definition: NPbase.h:3039
virtual const double muTHUVBFHZga(const double sqrt_s) const
Definition: NPbase.h:2848
virtual const double deltaGammaHbbRatio2() const
Definition: NPbase.h:2006
virtual const double muWHpT250(const double sqrt_s) const
The ratio between the W-Higgs associated production cross-section in the current model and in the St...
Definition: NPbase.h:1246
virtual const double muttHWW2l2v(const double sqrt_s) const
Definition: NPbase.h:1767
virtual const double STXS_ggH1j_pTH_120_200(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3416
virtual const double STXS12_qqHll_pTV250_400(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4368
virtual const double STXS12_qqHqq_VH_had_Nj2(const double sqrt_s) const
The STXS bin , VH-had Ref. 2402.05742.
Definition: NPbase.h:4088
virtual const double BrHVVRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2201
virtual const double muggHpttH(const double sqrt_s) const
The ratio between the sum of gluon-gluon fusion and t-tbar-Higgs associated production cross-section...
Definition: NPbase.h:1463
virtual const double STXS12_qqHqq_Nj1(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4107
virtual const double muTHUVHBRinv(const double sqrt_s) const
Definition: NPbase.h:3049
virtual const double delta_mutH_1(const double sqrt_s) const
Definition: NPbase.h:1939
virtual const double muTHUZHgaga(const double sqrt_s) const
Definition: NPbase.h:2828
virtual const double muTHUggHZZ(const double sqrt_s) const
Definition: NPbase.h:2868
virtual const double muTHUVBFHZZ(const double sqrt_s) const
Definition: NPbase.h:2872
virtual const double STXS12_ggH_pTH200_300_Nj01(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3785
virtual const double STXS12_ggHll_pTV150_250_Nj0(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4048
virtual const double muggHpttHptHpbbH_Hmumu(const double sqrt_s) const
Definition: NPbase.h:1799
virtual const double GammaHbbRatio() const
The ratio of the in the current model and in the Standard Model.
Definition: NPbase.h:2149
virtual const double STXS12_qqHqq_mjj350_700_pTH0_200_pTHjj25_Inf_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4161
virtual const double STXS12_qqHqq_mjj700_1000_pTH0_200_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4197
virtual const double muTHUggHWW2l2v(const double sqrt_s) const
Definition: NPbase.h:2942
virtual const double STXS_ggH2j_pTH_60_120(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3454
virtual const double STXS12_qqHqq_mjj350_1000_pTH200_Inf_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4224
virtual const double muVBFHZZ(const double sqrt_s) const
Definition: NPbase.h:1666
virtual const double muTHUggHWW(const double sqrt_s) const
Definition: NPbase.h:2918
virtual const double cgplusct() const
Definition: NPbase.h:2743
virtual const double muttHtautau(const double sqrt_s) const
Definition: NPbase.h:1831
virtual const double STXS_ZHqqHqq_pTj1_200(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3739
virtual const double muTHUggHZga(const double sqrt_s) const
Definition: NPbase.h:2844
virtual const double mueettH(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: NPbase.h:1475
virtual const double muTHUZHbb(const double sqrt_s) const
Definition: NPbase.h:3022
virtual const double STXS12_ggH_pTH650_Inf(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4017
virtual const double muVBFHWW(const double sqrt_s) const
Definition: NPbase.h:1723
virtual const double muWHWW(const double sqrt_s) const
Definition: NPbase.h:1731
virtual const double STXS12_qqHlv_pTV400_Inf(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4305
virtual const double muVBFHZga(const double sqrt_s) const
Definition: NPbase.h:1638
virtual const double muVBFHWW2l2v(const double sqrt_s) const
Definition: NPbase.h:1751
virtual const double deltaGammaTotalRatio1() const
Definition: NPbase.h:2038
virtual const double mueeZHGen(const double sqrt_s, const double Pol_em, const double Pol_ep) const
The ratio between the associated production cross-section in the current model and in the Standard ...
Definition: NPbase.h:1281
virtual const double STXS12_ggH_pTH60_120_Nj1(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3872
virtual const double STXS12_BrH4lRatio() const
The STXS BR , .
Definition: NPbase.h:3752
virtual const double STXS12_qqHqq_mjj350_700_pTH0_200_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4188
virtual const double STXS_ZHqqHqq_VBFtopo_j3(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3712
virtual const double BrH2e2vRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2362
virtual const double BrH2e2muRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2326
virtual const double BrHbbRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2304
virtual const double muggHgaga(const double sqrt_s) const
Definition: NPbase.h:1576
virtual const double muVHcc(const double sqrt_s) const
Definition: NPbase.h:1871
virtual const double mueeZllHPol(const double sqrt_s, const double Pol_em, const double Pol_ep) const
The ratio between the associated production cross-section in the current model and in the Standard ...
Definition: NPbase.h:1332
virtual const double STXS12_ggH_pTH650_Inf_Nj01(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3812
virtual const double muttHptH_Hgaga(const double sqrt_s) const
Definition: NPbase.h:1594
virtual const double STXS_qqHll_pTV_150_250(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3608
virtual const double BrHZgallRatio() const
The ratio of the Br ( ) in the current model and in the Standard Model.
Definition: NPbase.h:2221
virtual const double deltaGammaHZgaRatio2() const
Definition: NPbase.h:1997
virtual const double STXS12_ggH_pTH300_450_Nj01(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3794
virtual const double deltaGammaHmumuRatio1() const
Definition: NPbase.h:2011
virtual const double STXS12_qqHlv_pTV150_250_Nj0(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4260
virtual const double STXS12_qqHlv_pTV250_400(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4296
virtual const double STXS_WHqqHqq_VBFtopo_j3(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3667
virtual const double STXS_qqHll_pTV_150_250_0j(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3618
virtual const double muTHUWHbb(const double sqrt_s) const
Definition: NPbase.h:3026
virtual const double STXS_ttHtH(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3648
virtual const double muTHUVHZZ4l(const double sqrt_s) const
Definition: NPbase.h:2909
virtual const double muppHmumu(const double sqrt_s) const
Definition: NPbase.h:1875
virtual const double muTHUVHinv(const double sqrt_s) const
Definition: NPbase.h:3054
virtual const double BrHll_vvorjjRatio() const
The ratio of the Br ( ) in the current model and in the Standard Model.
Definition: NPbase.h:2648
virtual const double delta_muttH_2(const double sqrt_s) const
Definition: NPbase.h:1934
virtual const double muZHZga(const double sqrt_s) const
Definition: NPbase.h:1642
virtual const double deltaGammaHmumuRatio2() const
Definition: NPbase.h:2015
virtual const double STXS_ggH1j_pTH_0_60(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3398
virtual const double muZHWW2l2v(const double sqrt_s) const
Definition: NPbase.h:1755
virtual const double muttHWW(const double sqrt_s) const
Definition: NPbase.h:1739
virtual const double muVHZZ(const double sqrt_s) const
Definition: NPbase.h:1678
virtual const double STXS12_ttH_pTH200_300(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4413
virtual const double deltaGammaHZgaRatio1() const
Definition: NPbase.h:1993
virtual const double deltaGammaHWWRatio1() const
Definition: NPbase.h:1966
virtual const double muTHUVHgaga(const double sqrt_s) const
Definition: NPbase.h:2836
virtual const double STXS_qqHqq_VBFtopo_j3v(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3494
virtual const double muggHpbbH_HZZ(const double sqrt_s) const
Definition: NPbase.h:1662
virtual const double GammaHggRatio() const
The ratio of the in the current model and in the Standard Model.
Definition: NPbase.h:2056
virtual const double delta_muggH_1(const double sqrt_s) const
Definition: NPbase.h:1885
virtual const double STXS_qqHll_pTV_250(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3638
virtual const double muZH(const double sqrt_s) const
The ratio between the Z-Higgs associated production cross-section in the current model and in the St...
Definition: NPbase.h:1257
virtual const double delta_muVBF_1(const double sqrt_s) const
Definition: NPbase.h:1894
virtual const double STXS12_ggH_mjj700_Inf_pTH0_200_ptHjj0_25_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3935
virtual const double deltaGammaHZZRatio1() const
Definition: NPbase.h:1975
virtual const double muTHUVHWW(const double sqrt_s) const
Definition: NPbase.h:2934
virtual const double STXS_ZHqqHqq_VBFtopo_j3v(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3703
virtual const double GammaHZZRatio() const
The ratio of the in the current model and in the Standard Model.
Definition: NPbase.h:2076
virtual const double BrHZZRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2191
virtual const double STXS_qqHqq_nonVHtopo(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3513
virtual const double muWHZga(const double sqrt_s) const
Definition: NPbase.h:1646
virtual const double muTHUttHtautau(const double sqrt_s) const
Definition: NPbase.h:3010
virtual const double muVBFpVH_Hmumu(const double sqrt_s) const
Definition: NPbase.h:1803
virtual const double muttHptH_HZZ(const double sqrt_s) const
Definition: NPbase.h:1686
virtual const double muTHUVHWW2l2v(const double sqrt_s) const
Definition: NPbase.h:2958
virtual const double mueettHPol(const double sqrt_s, const double Pol_em, const double Pol_ep) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: NPbase.h:1488
virtual const double mueeZH(const double sqrt_s, const double Pol_em, const double Pol_ep) const
The ratio between the associated production cross-section in the current model and in the Standard ...
Definition: NPbase.h:1295
virtual const double STXS12_ggH_pTH450_650_Nj01(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3803
virtual const double GammaHWWRatio() const
The ratio of the in the current model and in the Standard Model.
Definition: NPbase.h:2066
virtual const double BrHtoinvRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2698
virtual const double muTHUttHgaga(const double sqrt_s) const
Definition: NPbase.h:2840
virtual const double BrH2muvRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2578
virtual const double STXS_ggH_VBFtopo_j3v(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3369
virtual const double muggHmumu(const double sqrt_s) const
Definition: NPbase.h:1771
virtual const double mueeHvvPol(const double sqrt_s, const double Pol_em, const double Pol_ep) const
The ratio between the associated production cross-section in the current model and in the Standard ...
Definition: NPbase.h:1175
virtual const double muggHWW2l2v(const double sqrt_s) const
Definition: NPbase.h:1747
virtual const double muttHptH_Htautau(const double sqrt_s) const
Definition: NPbase.h:1835
virtual const double STXS12_ttH_pTH300_Inf(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4422
virtual const double muZHbb(const double sqrt_s) const
Definition: NPbase.h:1851
virtual const double deltaGammaTotalRatio2() const
Definition: NPbase.h:2042
virtual const double STXS12_ggHll_pTV75_150(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4039
virtual const double STXS_qqHlv_pTV_250(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3590
virtual const double muWHWW2l2v(const double sqrt_s) const
Definition: NPbase.h:1759
virtual const double STXS12_ggHll_pTV0_75(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4030
virtual const double STXS12_ggH_mjj700_Inf_pTH0_200_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3962
virtual const double STXS_WHqqHqq_Rest(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3685
virtual const double STXS_ZHqqHqq_VH2j(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3721
virtual const double muZHtautau(const double sqrt_s) const
Definition: NPbase.h:1819
virtual const double muTHUVBFHgaga(const double sqrt_s) const
Definition: NPbase.h:2824
virtual const double deltaGammaHgagaRatio2() const
Definition: NPbase.h:1988
virtual const double muTHUWHWW(const double sqrt_s) const
Definition: NPbase.h:2930
virtual const double deltaGammaHgagaRatio1() const
Definition: NPbase.h:1984
virtual const double mutHgaga(const double sqrt_s) const
Definition: NPbase.h:1582
virtual const double muTHUWHWW2l2v(const double sqrt_s) const
Definition: NPbase.h:2954
virtual const double STXS12_ggH_mjj350_700_pTH0_200_ptHjj25_Inf_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3926
virtual const double mueeZqqHPol(const double sqrt_s, const double Pol_em, const double Pol_ep) const
The ratio between the associated production cross-section in the current model and in the Standard ...
Definition: NPbase.h:1345
virtual const double STXS12_ggH_pTH10_200_Nj0(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3840
virtual const double BrHssRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2294
virtual const double delta_muttH_1(const double sqrt_s) const
Definition: NPbase.h:1930
virtual const double muZHgaga(const double sqrt_s) const
Definition: NPbase.h:1618
virtual const double UpperLimitZgammaC(const double sqrt_s) const
Definition: NPbase.h:2734
virtual const double BrH4lRatio() const
The ratio of the Br ( ) in the current model and in the Standard Model.
Definition: NPbase.h:2599
virtual const double STXS_qqHqq_VHtopo(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3522
virtual const double muWHgaga(const double sqrt_s) const
Definition: NPbase.h:1622
virtual const double STXS12_BrHevmuvRatio() const
The STXS BR .
Definition: NPbase.h:3760
virtual const double STXS_qqHlv_pTV_0_250(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3550
virtual const double Br_H_inv() const
The branching ratio of the of the Higgs into invisible particles.
Definition: NPbase.h:2668
virtual const double STXS12_ttH_pTH300_450(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4431
virtual const double BrHggRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2171
virtual const double STXS12_ggH_mjj700_Inf_pTH0_200_ptHjj25_Inf_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3944
virtual const double muVBFHZZ4l(const double sqrt_s) const
Definition: NPbase.h:1694
virtual const double mummH(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: NPbase.h:1499
virtual const double mummHNWA(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model,...
Definition: NPbase.h:1511
virtual const double STXS_ggH2j_pTH_0_200(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3434
virtual const double STXS12_ggH_pTH200_300(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3973
virtual const double BrHgagaRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2251
virtual const double muVBFHbb(const double sqrt_s) const
Definition: NPbase.h:1847
virtual const double STXS12_qqHqq_mjj0_60_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4116
virtual const double mueeZBF(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: NPbase.h:1187
virtual const double STXS_ggH1j_pTH_60_120(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3407
virtual const double UpperLimitZgammaA13(const double sqrt_s) const
Definition: NPbase.h:2707
virtual const double muTHUVBFHmumu(const double sqrt_s) const
Definition: NPbase.h:2970
virtual const double STXS12_ggH_mjj350_700_pTH0_200_ptHjj0_25_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3917
virtual const double STXS12_qqHll_pTV0_75(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4314
virtual const double muTHUggHZZ4mu(const double sqrt_s) const
Definition: NPbase.h:3059
virtual const double computeGammaTotalRatio() const
The ratio of the in the current model and in the Standard Model.
Definition: NPbase.h:2159
virtual const double STXS12_ggH_mjj350_700_pTH0_200_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3953
virtual const double muTHUWHtautau(const double sqrt_s) const
Definition: NPbase.h:3002
virtual const double muTHUVBFHZZ4l(const double sqrt_s) const
Definition: NPbase.h:2897
virtual const double muZHWW(const double sqrt_s) const
Definition: NPbase.h:1727
virtual const double STXS12_qqHqq_mjj60_120_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4125
virtual const double STXS12_qqHqq_mjj700_Inf_pTH0_200_pTHjj0_25_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4170
virtual const double cbminusctau() const
Definition: NPbase.h:2797
virtual const double BrHlvjjRatio() const
The ratio of the Br ( ) in the current model and in the Standard Model.
Definition: NPbase.h:2630
virtual const double muVBFpVH(const double sqrt_s) const
The ratio between the sum of VBF and WH+ZH associated production cross-section in the current model ...
Definition: NPbase.h:1407
virtual const double GammaHssRatio() const
The ratio of the in the current model and in the Standard Model.
Definition: NPbase.h:2139
virtual const double BrH2mu2vRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2371
virtual const double mueeWBFPol(const double sqrt_s, const double Pol_em, const double Pol_ep) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: NPbase.h:1150
virtual const double muTHUttHZZ4l(const double sqrt_s) const
Definition: NPbase.h:2913
virtual const double muWHZZ4l(const double sqrt_s) const
Definition: NPbase.h:1702
virtual const double UpperLimitZgammaC13(const double sqrt_s) const
Definition: NPbase.h:2716
virtual const double muTHUttHWW2l2v(const double sqrt_s) const
Definition: NPbase.h:2962
virtual const double STXS12_ggHll_pTV150_250_Nj1(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4057
virtual const double mueeZBFPol(const double sqrt_s, const double Pol_em, const double Pol_ep) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: NPbase.h:1200
virtual const double STXS12_ggH_mjj0_350_pTH120_200_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3908
virtual const double GammaHZgaRatio() const
The ratio of the in the current model and in the Standard Model.
Definition: NPbase.h:2086
virtual const double GammaHgagaRatio() const
The ratio of the in the current model and in the Standard Model.
Definition: NPbase.h:2096
virtual const double Br_H_exo() const
The branching ratio of the of the Higgs into exotic particles.
Definition: NPbase.h:2659
virtual const double muggHpbbH_Hgaga(const double sqrt_s) const
Definition: NPbase.h:1588
virtual const double muWHbb(const double sqrt_s) const
Definition: NPbase.h:1855
virtual const double muVHWW(const double sqrt_s) const
Definition: NPbase.h:1735
virtual const double muTHUVHZZ(const double sqrt_s) const
Definition: NPbase.h:2884
virtual const double muggHH(const double sqrt_s) const
The ratio between the gluon-gluon fusion di-Higgs production cross-section in the current model and ...
Definition: NPbase.h:1102
virtual const double STXS_ggH2j_pTH_120_200(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3464
virtual const double muttHZbbboost(const double sqrt_s) const
The ratio in the channel in the current model and in the Standard Model.
Definition: NPbase.h:1571
virtual const double STXS_qqHqq_VBFtopo_Rest(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3484
virtual const double muTHUWHZZ4l(const double sqrt_s) const
Definition: NPbase.h:2905
virtual const double STXS_WHqqHqq_VH2j(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3676
virtual const double deltaGammaHZZRatio2() const
Definition: NPbase.h:1979
virtual const double muWHtautau(const double sqrt_s) const
Definition: NPbase.h:1823
virtual const double muTHUggHtautau(const double sqrt_s) const
Definition: NPbase.h:2990
virtual const double GammaHmumuRatio() const
The ratio of the in the current model and in the Standard Model.
Definition: NPbase.h:2109
virtual const double STXS12_ggH_mjj0_350_pTH0_60_Nj1(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3851
virtual const double STXS12_qqHqq_mjj1000_1500_pTH0_200_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4206
virtual const double BrHZgaeeRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2231
virtual const double STXS_WHqqHqq_pTj1_200(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3694
virtual const double BrHevmuvRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2515
virtual const double muTHUVBFHinv(const double sqrt_s) const
Definition: NPbase.h:3044
virtual const double muggHpVBFpbbH_Hbb(const double sqrt_s) const
Definition: NPbase.h:1843
virtual const double GammaHtautauRatio() const
The ratio of the in the current model and in the Standard Model.
Definition: NPbase.h:2119
virtual const double muTHUggHgaga(const double sqrt_s) const
Definition: NPbase.h:2819
virtual const double muVHbb(const double sqrt_s) const
Definition: NPbase.h:1859
virtual const double STXS12_qqHll_pTV400_Inf(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4377
virtual const double muTHUggHZZ4l(const double sqrt_s) const
Definition: NPbase.h:2893
virtual const double muttHgaga(const double sqrt_s) const
Definition: NPbase.h:1630
virtual const double muTHUggHbb(const double sqrt_s) const
Definition: NPbase.h:3014
virtual const double muTHUWHgaga(const double sqrt_s) const
Definition: NPbase.h:2832
virtual const double muWHmumu(const double sqrt_s) const
Definition: NPbase.h:1783
virtual const double muZHZZ(const double sqrt_s) const
Definition: NPbase.h:1670
virtual const double muttHZZ(const double sqrt_s) const
Definition: NPbase.h:1682
virtual const double deltaGammaHbbRatio1() const
Definition: NPbase.h:2002
virtual const double muWH(const double sqrt_s) const
The ratio between the W-Higgs associated production cross-section in the current model and in the St...
Definition: NPbase.h:1235
virtual const double STXS12_tH(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:4449
virtual const double muWHZZ(const double sqrt_s) const
Definition: NPbase.h:1674
virtual const double Br_H_inv_NP() const
The branching ratio of the of the Higgs into invisible particles (only invisible new particles).
Definition: NPbase.h:2678
virtual const double muggHtautau(const double sqrt_s) const
Definition: NPbase.h:1807
virtual const double muttHmumu(const double sqrt_s) const
Definition: NPbase.h:1791
virtual const double STXS12_ggH_pTH0_60_Nj1(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3863
virtual const double muggHZZ(const double sqrt_s) const
Definition: NPbase.h:1658
virtual const double BrHlljjRatio() const
The ratio of the Br ( ) in the current model and in the Standard Model.
Definition: NPbase.h:2621
virtual const double muTHUVBFHWW(const double sqrt_s) const
Definition: NPbase.h:2922
virtual const double STXS12_qqHqq_mjj1000_Inf_pTH200_Inf_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4233
virtual const double STXS_qqHlv_pTV_150_250_0j(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3570
virtual const double STXS12_qqHll_pTV150_250_Nj0(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4332
virtual const double BrHvisRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2688
virtual const double STXS12_BrHgagaRatio() const
The STXS BR .
Definition: NPbase.h:3768
virtual const double BrHccRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2284
virtual const double muVBFHtautau(const double sqrt_s) const
Definition: NPbase.h:1815
virtual const double muTHUVHbb(const double sqrt_s) const
Definition: NPbase.h:3030
virtual const double bPskPol(const double sqrt_s, const double Pol_em, const double Pol_ep) const
the angular parameter from (arXiv:1708.09079 [hep-ph]).
Definition: NPbase.h:1371
virtual const double muVHpT250(const double sqrt_s) const
The ratio between the WH+ZH associated production cross-section in the current model and in the Stan...
Definition: NPbase.h:1395
virtual const double delta_muVBF_2(const double sqrt_s) const
Definition: NPbase.h:1898
virtual const double STXS_ggH0j(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3389
virtual const double STXS12_qqHqq_VH_veto_Nj01(const double sqrt_s) const
The STXS bin , VH-veto Ref. 2402.05742.
Definition: NPbase.h:4077
virtual const double STXS12_qqHll_pTV150_250_Nj1(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4341
virtual const double mutHq(const double sqrt_s) const
The ratio between the t-q-Higgs associated production cross-section in the current model and in the ...
Definition: NPbase.h:1451
virtual const double muTHUggHZgamumu(const double sqrt_s) const
Definition: NPbase.h:3064
virtual const double STXS_ggH2j_pTH_0_60(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3444
virtual const double STXS12_ggH_pTH10_Inf_Nj0(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3830
virtual const double mummHvv(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: NPbase.h:1535
virtual const double STXS12_qqHlv_pTV0_75(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4242
virtual const double muVHtautau(const double sqrt_s) const
Definition: NPbase.h:1827
virtual const double BrH2l2vRatio() const
The ratio of the Br ( ) in the current model and in the Standard Model.
Definition: NPbase.h:2608
virtual const double BrH4muRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2470
virtual const double muttHZga(const double sqrt_s) const
Definition: NPbase.h:1654
virtual const double muTHUZHtautau(const double sqrt_s) const
Definition: NPbase.h:2998
virtual const double BrHmumuRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2264
virtual const double muVBFHgaga(const double sqrt_s) const
Definition: NPbase.h:1614
virtual const double STXS12_qqHqq_mjj120_350_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4134
virtual const double STXS12_ggH_pTH120_200_Nj1(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3881
virtual const double UpperLimitZgammaA(const double sqrt_s) const
Definition: NPbase.h:2725
virtual const double muTHUZHZga(const double sqrt_s) const
Definition: NPbase.h:2852
virtual const double BrHWWRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2181
virtual const double muTHUVBFHWW2l2v(const double sqrt_s) const
Definition: NPbase.h:2946
virtual const double BrHZgamumuRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2241
virtual const double mueeZllH(const double sqrt_s) const
The ratio between the associated production cross-section in the current model and in the Standard ...
Definition: NPbase.h:1307
virtual const double delta_muZH_1(const double sqrt_s) const
Definition: NPbase.h:1912
virtual const double muVHmumu(const double sqrt_s) const
Definition: NPbase.h:1787
virtual const double STXS_WHqqHqq_VBFtopo_j3v(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3658
virtual const double muTHUVHmumu(const double sqrt_s) const
Definition: NPbase.h:2982
virtual const double cgminuscga() const
Definition: NPbase.h:2761
virtual const double STXS0_qqH(const double sqrt_s) const
The STXS0 bin .
Definition: NPbase.h:3357
virtual const double delta_muggH_2(const double sqrt_s) const
Definition: NPbase.h:1889
virtual const double muTHUWHZZ(const double sqrt_s) const
Definition: NPbase.h:2880
virtual const double STXS12_qqHqq_mjj700_Inf_pTH0_200_pTHjj25_Inf_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4179
virtual const double muTHUVHtautau(const double sqrt_s) const
Definition: NPbase.h:3006
virtual const double muZHpT250(const double sqrt_s) const
The ratio between the Z-Higgs associated production cross-section in the current model and in the St...
Definition: NPbase.h:1268
virtual const double muppHZga(const double sqrt_s) const
Definition: NPbase.h:1879
virtual const double STXS_qqHqq_pTj_200(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3541
virtual const double STXS_qqHlv_pTV_0_150(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3560
virtual const double muVBFgamma(const double sqrt_s) const
The ratio between the vector-boson fusion Higgs production cross-section in association with a hard ...
Definition: NPbase.h:1125
virtual const double muggHgagaInt(const double sqrt_s) const
The ratio between the gluon-gluon fusion Higgs production cross-section with subsequent decay into 2...
Definition: NPbase.h:1609
virtual const double BrHlv_lvorjjRatio() const
The ratio of the Br ( ) in the current model and in the Standard Model.
Definition: NPbase.h:2639
virtual const double muggH(const double sqrt_s) const
The ratio between the gluon-gluon fusion Higgs production cross-section in the current model and in ...
Definition: NPbase.h:1091
virtual const double deltaGammaHWWRatio2() const
Definition: NPbase.h:1970
virtual const double STXS12_ttH_pTH450_Inf(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4440
virtual const double muggHWW(const double sqrt_s) const
Definition: NPbase.h:1715
virtual const double cVplusctau() const
Definition: NPbase.h:2779
virtual const double muTHUZHWW2l2v(const double sqrt_s) const
Definition: NPbase.h:2950
virtual const double STXS_ZHqqHqq_Rest(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3730
virtual const double muepZBF(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: NPbase.h:1224
virtual const double delta_muWH_1(const double sqrt_s) const
Definition: NPbase.h:1903
virtual const double muTHUVBFHtautau(const double sqrt_s) const
Definition: NPbase.h:2994
virtual const double muggHpbbH_HWW(const double sqrt_s) const
Definition: NPbase.h:1719
virtual const double STXS12_qqHll_pTV75_150(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4323
virtual const double delta_muWH_2(const double sqrt_s) const
Definition: NPbase.h:1907
virtual const double muttHbb(const double sqrt_s) const
Definition: NPbase.h:1863
virtual const double muVHZZ4l(const double sqrt_s) const
Definition: NPbase.h:1706
virtual const double muTHUWHZga(const double sqrt_s) const
Definition: NPbase.h:2856
virtual const double mutH(const double sqrt_s) const
The ratio between the t-Higgs associated production cross-section in the current model and in the St...
Definition: NPbase.h:1429
virtual const double STXS12_ttH_pTH60_120(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4395
virtual const double aPskPol(const double sqrt_s, const double Pol_em, const double Pol_ep) const
the angular parameter from (arXiv:1708.09079 [hep-ph]).
Definition: NPbase.h:1358
virtual const double muTHUVBFHbb(const double sqrt_s) const
Definition: NPbase.h:3018
virtual const double muTHUWHmumu(const double sqrt_s) const
Definition: NPbase.h:2978
virtual const double STXS12_qqHlv_pTV250_Inf(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4278
virtual const double mueeZqqH(const double sqrt_s) const
The ratio between the associated production cross-section in the current model and in the Standard ...
Definition: NPbase.h:1319
virtual const double STXS_qqHlv_pTV_150_250_1j(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3580
virtual const double muTHUZHZZ4l(const double sqrt_s) const
Definition: NPbase.h:2901
virtual const double STXS12_qqHll_pTV250_Inf(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4350
virtual const double muttHptH_Hmumu(const double sqrt_s) const
Definition: NPbase.h:1795
virtual const double muVHgaga(const double sqrt_s) const
Definition: NPbase.h:1626
virtual const double muttHptH_Hbb(const double sqrt_s) const
Definition: NPbase.h:1867
virtual const double muTHUttHmumu(const double sqrt_s) const
Definition: NPbase.h:2986
virtual const double STXS12_ttH_pTH120_200(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4404
virtual const double STXS_qqHqq_Rest(const double sqrt_s) const
The STXS bin .
Definition: NPbase.h:3532
virtual const double BrHtautauRatio() const
The ratio of the Br in the current model and in the Standard Model.
Definition: NPbase.h:2274
virtual const double muTHUggHmumu(const double sqrt_s) const
Definition: NPbase.h:2966
virtual const double muZHZZ4l(const double sqrt_s) const
Definition: NPbase.h:1698
virtual const double STXS12_ggH_pTH0_10_Nj0(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:3821
virtual const double muTHUZHWW(const double sqrt_s) const
Definition: NPbase.h:2926
virtual const double mummHmm(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model.
Definition: NPbase.h:1547
virtual const double STXS12_qqHqq_mjj1500_Inf_pTH0_200_Nj2(const double sqrt_s) const
The STXS bin , .
Definition: NPbase.h:4215
virtual const double muTHUVHZga(const double sqrt_s) const
Definition: NPbase.h:2860
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_VHlep(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
unsigned int fstate
STXS12_ggH_mjj0_350_pTH0_120_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_mjj0_350_pTH0_60_Nj1(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_mjj0_350_pTH0_60_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_ggH_mjj0_350_pTH120_200_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_mjj0_350_pTH60_120_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_mjj350_700_pTH0_200_ptHjj0_25_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_ggH_mjj350_700_pTH0_200_ptHjj25_Inf_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_mjj350_Inf_pTH0_200_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_mjj700_Inf_pTH0_200_ptHjj0_25_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_mjj700_Inf_pTH0_200_ptHjj25_Inf_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH0_10_Nj0(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH0_200_Nj0(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_ggH_pTH0_200_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH0_60_Nj1(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH10_200_Nj0(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH10_Inf_Nj0(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_ggH_pTH120_200_Nj1(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH200_300_Nj01(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH200_300(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH200_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH300_450_Nj01(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_ggH_pTH300_450(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH300_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_ggH_pTH450_650_Nj01(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH450_650(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH450_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_ggH_pTH60_120_Nj1(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH650_Inf_Nj01(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH650_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggHll_pTV0_75(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggHll_pTV150_250_Nj0(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggHll_pTV150_250_Nj1(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_ggHll_pTV250_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggHll_pTV75_150(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_qqHll_pTV0_150(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHll_pTV0_75(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHll_pTV150_250_Nj0(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHll_pTV150_250_Nj1(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_qqHll_pTV150_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHll_pTV250_400(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHll_pTV250_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_qqHll_pTV400_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHll_pTV75_150(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_qqHlv_pTV0_150(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHlv_pTV0_75(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHlv_pTV150_250_Nj0(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_qqHlv_pTV150_250_Nj1(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHlv_pTV150_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHlv_pTV250_400(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHlv_pTV250_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHlv_pTV400_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_qqHlv_pTV75_150(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
const NPbase * myNPbase
STXS12_qqHqq_Nj0(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_Nj1(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_VH_had_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_qqHqq_VH_veto_Nj01(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj0_60_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj1000_1500_pTH0_200_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_qqHqq_mjj1000_Inf_pTH0_200_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj1000_Inf_pTH200_Inf_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj120_350_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj1500_Inf_pTH0_200_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj350_1000_pTH200_Inf_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj350_700_pTH0_200_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj350_700_pTH0_200_pTHjj0_25_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_qqHqq_mjj350_700_pTH0_200_pTHjj25_Inf_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj350_Inf_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj350_Inf_pTH200_Inf_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_qqHqq_mjj60_120_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj700_1000_pTH0_200_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj700_Inf_pTH0_200_pTHjj0_25_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_qqHqq_mjj700_Inf_pTH0_200_pTHjj25_Inf_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_tH(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
const NPbase * myNPbase
const double sqrt_s
unsigned int fstate
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ttH_pTH0_120(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_ttH_pTH0_60(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ttH_pTH120_200(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ttH_pTH200_300(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ttH_pTH300_450(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ttH_pTH300_Inf_add(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ttH_pTH300_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ttH_pTH450_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_ttH_pTH60_120(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ttH(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
const NPbase * myNPbase
unsigned int fstate
const double sqrt_s
const double sqrt_s
const NPbase * myNPbase
STXS_0_qqH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSWHqqHqq_Rest_2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSWHqqHqq_VBFtopo_j3_2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSWHqqHqq_VBFtopo_j3v_2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSWHqqHqq_VH2j_2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSWHqqHqq_pTj1_200_2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSZHqqHqq_Rest_2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSZHqqHqq_VBFtopo_j3_2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSZHqqHqq_VBFtopo_j3v_2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSZHqqHqq_VH2j_2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSZHqqHqq_pTj1_200_2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
STXSggH0j4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSggH1j_pTH_0_60_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSggH1j_pTH_120_200_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSggH1j_pTH_200_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSggH1j_pTH_60_120_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSggH2j_pTH_0_200_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSggH2j_pTH_0_60_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSggH2j_pTH_120_200_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSggH2j_pTH_200_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSggH2j_pTH_60_120_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSggH_VBFtopo_j3_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSggH_VBFtopo_j3v_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHll_pTV_0_150_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHll_pTV_0_150_bb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHll_pTV_150_250_0j_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHll_pTV_150_250_0j_bb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHll_pTV_150_250_1j_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSqqHll_pTV_150_250_1j_bb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHll_pTV_150_250_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHll_pTV_150_250_bb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSqqHll_pTV_250_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHll_pTV_250_bb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHlv_pTV_0_150_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSqqHlv_pTV_0_150_bb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHlv_pTV_0_250_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHlv_pTV_0_250_bb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSqqHlv_pTV_150_250_0j_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHlv_pTV_150_250_0j_bb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSqqHlv_pTV_150_250_1j_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHlv_pTV_150_250_1j_bb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHlv_pTV_250_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHlv_pTV_250_bb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHqq_Rest_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSqqHqq_VBFtopo_Rest_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHqq_VBFtopo_j3_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHqq_VBFtopo_j3v_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSqqHqq_VHtopo_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHqq_nonVHtopo_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHqq_pTj_200_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSttHtH4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of the STXS bin in the current model.
A model class for the Standard Model.
A class for a model prediction of an observable.
Definition: ThObservable.h:25
const StandardModel & getModel()
A get method to get the model.
Definition: ThObservable.h:100
const StandardModel & SM
A reference to an object of StandardMode class.
Definition: ThObservable.h:121
double computeThValue()
A method to compute.
UpperLimit_ppHZgammaA13(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute.
UpperLimit_ppHZgammaA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
UpperLimit_ppHZgammaC13(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute.
UpperLimit_ppHZgammaC(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute.
VBFHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of .
const NPbase * myNPbase
const double sqrt_s
const double sqrt_s
double computeThValue()
A method to compute the value of .
VBFHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of .
const double sqrt_s
const NPbase * myNPbase
VBFHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
VBFHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of .
const NPbase * myNPbase
WHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of .
const double sqrt_s
double computeThValue()
A method to compute the value of .
WHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of .
WHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of .
WHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of .
const double sqrt_s
ZHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of .
const double sqrt_s
const NPbase * myNPbase
ZHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of .
ZHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of .
const double sqrt_s
ZHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
aPsk(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double Pol_ep
double computeThValue()
A method to compute the value of the angular parameter from in the current model.
const double sqrt_s
const double Pol_em
const NPbase * myNPbase
const double Pol_ep
const double sqrt_s
const NPbase * myNPbase
const double Pol_em
bPsk(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of the angular parameter from in the current model.
cV_plus_cb(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute.
cV_plus_ctau(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute.
const NPbase * myNPbase
cb_minus_cc(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute.
const NPbase * myNPbase
const NPbase * myNPbase
cb_minus_ctau(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute.
double computeThValue()
A method to compute.
cc_minus_ctau(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute.
const NPbase * myNPbase
cg_minus_cga(const StandardModel &SM_i)
Constructor.
cg_plus_ct(const StandardModel &SM_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute.
double computeThValue()
A method to compute.
const NPbase * myNPbase
cga_plus_ct(const StandardModel &SM_i)
Constructor.
ggHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of .
const double sqrt_s
double computeThValue()
A method to compute the value of .
ggHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
ggHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of .
const NPbase * myNPbase
const double sqrt_s
ggHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of .
const NPbase * myNPbase
muTHUVBFBRinv(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
muTHUVBFHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muTHUVBFHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
muTHUVBFHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muTHUVBFHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
muTHUVBFHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
muTHUVBFHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const NPbase * myNPbase
muTHUVBFHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUVBFHinv(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
muTHUVBFHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
muTHUVBFHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
muTHUVHBRinv(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muTHUVHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muTHUVHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const NPbase * myNPbase
muTHUVHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
muTHUVHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
muTHUVHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const double sqrt_s
muTHUVHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
muTHUVHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
muTHUVHinv(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
muTHUVHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muTHUVHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
muTHUWHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
muTHUWHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUWHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const double sqrt_s
muTHUWHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muTHUWHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const NPbase * myNPbase
muTHUWHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const double sqrt_s
muTHUWHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
const double sqrt_s
muTHUWHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muTHUWHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muTHUZHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
muTHUZHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muTHUZHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
const double sqrt_s
const NPbase * myNPbase
muTHUZHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUZHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
muTHUZHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
const double sqrt_s
muTHUZHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
muTHUZHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
muTHUZHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muTHUggHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
muTHUggHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUggHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
muTHUggHZZ4mu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
muTHUggHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
muTHUggHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muTHUggHZgamumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
muTHUggHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
muTHUggHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
muTHUggHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
muTHUggHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUttHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
muTHUttHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const double sqrt_s
muTHUttHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
muTHUttHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muTHUttHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
muTHUttHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
muTHUttHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
muTHUttHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muTHUttHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muVBFBRinv(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
muVBFHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
const double sqrt_s
double computeThValue()
const NPbase * myNPbase
muVBFHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muVBFHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
muVBFHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
const NPbase * myNPbase
const double sqrt_s
const double sqrt_s
double computeThValue()
const NPbase * myNPbase
muVBFHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
muVBFHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
const NPbase * myNPbase
muVBFHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
const double sqrt_s
muVBFHinv(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
muVBFHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
muVBFHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
muVBF(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
muVBFgamma(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muVBFpVH_Hmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muVBFpVH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const NPbase * myNPbase
muVBFpVHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
muVHBRinv(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
muVH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const double sqrt_s
const NPbase * myNPbase
muVHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
muVHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
const NPbase * myNPbase
muVHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const double sqrt_s
muVHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
const double sqrt_s
const NPbase * myNPbase
muVHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
const double sqrt_s
muVHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
const NPbase * myNPbase
muVHcc(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
const double sqrt_s
muVHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
muVHinv(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
muVHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
muVHpT250(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
muVHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
muWH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muWHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
muWHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
const NPbase * myNPbase
const double sqrt_s
muWHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
const NPbase * myNPbase
double computeThValue()
const double sqrt_s
muWHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
muWHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
muWHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muWHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
muWHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muWHpT250(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
muWHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
muZH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
muZHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
const double sqrt_s
double computeThValue()
const NPbase * myNPbase
muZHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muZHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
muZHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
muZHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const NPbase * myNPbase
muZHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
double computeThValue()
const NPbase * myNPbase
muZHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
muZHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
const double sqrt_s
muZHpT250(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
muZHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const double sqrt_s
mueeHvv(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const NPbase * myNPbase
mueeHvvPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double Pol_em
const double Pol_ep
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
mueeHvvWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mueeHvvWWPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const double Pol_em
const NPbase * myNPbase
const double Pol_ep
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
mueeHvvZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
mueeHvvZZPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double sqrt_s
const double Pol_ep
const NPbase * myNPbase
const double Pol_em
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
mueeHvvZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double Pol_em
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double Pol_ep
mueeHvvZgaPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
mueeHvvbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const double Pol_em
const double Pol_ep
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
mueeHvvbbPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
mueeHvvcc(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const double Pol_em
mueeHvvccPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double Pol_ep
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mueeHvvgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
mueeHvvgagaPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mueeHvvgg(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double Pol_em
const double Pol_ep
mueeHvvggPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double sqrt_s
mueeHvvmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mueeHvvmumuPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mueeHvvtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mueeHvvtautauPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mueeWBF(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
mueeWBFPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double Pol_em
const double Pol_ep
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mueeWBFWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
mueeWBFZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
mueeWBFZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
const NPbase * myNPbase
mueeWBFbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const double Pol_em
const double Pol_ep
mueeWBFbbPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mueeWBFcc(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
mueeWBFgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
mueeWBFgg(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
mueeWBFmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
mueeWBFtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mueeZBF(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
const double Pol_em
const double Pol_ep
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
mueeZBFPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mueeZBFbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
const double Pol_em
mueeZBFbbPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double Pol_ep
const NPbase * myNPbase
const double Pol_em
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
mueeZHBRinv(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double Pol_ep
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mueeZHGen(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double sqrt_s
const double Pol_ep
const double Pol_em
const double Pol_em
const NPbase * myNPbase
const double Pol_ep
const double sqrt_s
mueeZH(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
mueeZHWW(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double Pol_ep
const double Pol_em
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const double Pol_em
const double Pol_ep
mueeZHZZ(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
mueeZHZga(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double sqrt_s
const double Pol_em
double computeThValue()
A method to compute the value of in the current model.
const double Pol_ep
mueeZHbb(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double Pol_em
const double sqrt_s
const double Pol_ep
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double Pol_ep
const NPbase * myNPbase
const double Pol_em
mueeZHcc(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double sqrt_s
const double Pol_ep
mueeZHgaga(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
const double Pol_em
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
const double Pol_em
const double Pol_ep
mueeZHgg(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
const double Pol_em
mueeZHinv(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double Pol_ep
double computeThValue()
A method to compute the value of in the current model.
const double Pol_ep
const NPbase * myNPbase
const double Pol_em
mueeZHmumu(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double sqrt_s
const double Pol_ep
mueeZHss(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const double Pol_em
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
const double Pol_ep
double computeThValue()
A method to compute the value of in the current model.
const double Pol_em
mueeZHtautau(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
mueeZllH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mueeZllHPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double Pol_em
const double Pol_ep
double computeThValue()
A method to compute the value of in the current model.
mueeZqqH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const double Pol_ep
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mueeZqqHPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const double Pol_em
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mueettH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
mueettHPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
const NPbase * myNPbase
const double Pol_em
const double Pol_ep
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
mueettHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const double Pol_ep
const double sqrt_s
const double Pol_em
const NPbase * myNPbase
mueettHbbPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
muepWBF(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
muepWBFWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
muepWBFZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muepWBFbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const double sqrt_s
muepWBFcc(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
muepWBFgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
muepWBFgg(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
muepWBFtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
muepZBF(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
muepZBFWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
muepZBFZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
muepZBFbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
muepZBFcc(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
muepZBFgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
muepZBFgg(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
muepZBFtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
muggHH2ga2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
muggH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
muggHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
const double sqrt_s
const NPbase * myNPbase
muggHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
const double sqrt_s
muggHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
muggHZZ4mu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muggHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
const double sqrt_s
const NPbase * myNPbase
muggHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
muggHZgamumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
const double sqrt_s
muggHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muggHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
const NPbase * myNPbase
muggHgagaInt(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
muggHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
muggHpVBFpbbH_Hbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
muggHpbbH_HWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
muggHpbbH_HZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
muggHpbbH_Hgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muggHpbbH_Htautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
const double sqrt_s
muggHpttH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
muggHpttHptHpbbH_Hmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muggHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mummH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mummHNWA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mummHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mummHWWNWA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mummHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mummHZZNWA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
mummHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
mummHZgaNWA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mummHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mummHbbNWA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mummHcc(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
mummHccNWA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
const double sqrt_s
mummHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
mummHgagaNWA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
mummHgg(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mummHggNWA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mummHmmWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
mummHmmZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
const double sqrt_s
mummHmmZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
mummHmmbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mummHmmcc(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
mummHmmgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
const NPbase * myNPbase
mummHmmgg(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
mummHmmmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
mummHmmtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mummHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
mummHmumuNWA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mummHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
mummHtautauNWA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const NPbase * myNPbase
mummHvv(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mummHvvWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const double sqrt_s
mummHvvZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mummHvvZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mummHvvbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mummHvvcc(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
mummHvvgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const NPbase * myNPbase
mummHvvgg(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
mummHvvmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
mummHvvtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mummZH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mummZHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
mummZHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
mummZHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mummZHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
mummZHcc(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mummZHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mummZHgg(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
mummZHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
const double sqrt_s
const NPbase * myNPbase
mummZHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
mummttH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mummttHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mummttHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
mummttHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
mummttHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
mummttHcc(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
mummttHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
mummttHgg(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
const double sqrt_s
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
mummttHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
mummttHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the current model.
const NPbase * myNPbase
double computeThValue()
const double sqrt_s
muppHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
muppHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
double computeThValue()
const double sqrt_s
mutHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
mutHq(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muttH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
const double sqrt_s
const NPbase * myNPbase
muttHVV(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
muttHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
muttHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
const double sqrt_s
muttHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
double computeThValue()
const NPbase * myNPbase
const NPbase * myNPbase
double computeThValue()
const double sqrt_s
muttHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muttHZbbboost(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
A method to compute the value of in the channel in the current model.
muttHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
muttHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
const double sqrt_s
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
muttHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muttHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
double computeThValue()
muttHptH_HWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
muttHptH_HZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const double sqrt_s
const NPbase * myNPbase
muttHptH_Hbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
muttHptH_Hgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
const NPbase * myNPbase
muttHptH_Hmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muttHptH_Htautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
muttHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase
const double sqrt_s
ttHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const NPbase * myNPbase
double computeThValue()
A method to compute the value of .
const NPbase * myNPbase
double computeThValue()
A method to compute the value of .
const double sqrt_s
ttHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
ttHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of .
const double sqrt_s
const NPbase * myNPbase
double computeThValue()
A method to compute the value of .
ttHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
const double sqrt_s
const NPbase * myNPbase